+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
+Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkselection.h:
+ * gtk/gtkselection.c: new functions gtk_selection_data_copy and
+ gtk_selection_data_free.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
+ for "selection_received", which was completely bogus.
+ * other fixups to gtk_signal_new() calls all over the place.
+
+ * gtk/gtktypebuiltins.h: types as variables (formerly macros).
+ * gtk/gtktypebuiltins_vars.c: type variable implementations.
+ * gtk/gtktypebuiltins_ids.c: array entries for builtin type
+ declarations.
+ * gtk/gtktypebuiltins_evals.c: enum value arrays.
+ * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
+ gtk.defs.
+ * gtk/gtk.defs: generated file with scheme syntax for type definitions
+ of gtk and gdk structures and enums.
+ * gtk/gtktypeutils.h:
+ * gtk/gtktypeutils.c: reworked type ids, so they are variables not
+ macros anymore (this fixes binary incompatibility with new enum
+ definitions).
+
+ * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
+ key bindings for this widget.
+ * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
+ handler.
+
+ * gtk/gtkobject.h:
+ * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
+ again. new functions gtk_object_class_user_signal_new () and
+ gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
+ flag on the signal creation.
+
+Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
+
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:
G_NV (GDK_BUTTON3_MASK, button3-mask, 1 << 10),
G_NV (GDK_BUTTON4_MASK, button4-mask, 1 << 11),
G_NV (GDK_BUTTON5_MASK, button5-mask, 1 << 12),
- G_NV (GDK_AFTER_MASK, after-mask, 1 << 13),
- G_NV (GDK_MODIFIER_MASK, modifier-mask, 0x3fff)
+ G_NV (GDK_MODIFIER_MASK, modifier-mask, 0x1fff)
} G_FLAGS (GdkModifierType);
typedef enum
gtktypebuiltins.h
auto-files:
- make $(srcdir)/gtk.defs
- make $(srcdir)/gtktypebuiltins1.c
- make $(srcdir)/gtktypebuiltins2.c
+ rm -f $(srcdir)/gtk.defs
+ make $(srcdir)/gtktypebuiltins_evals.c
+ make $(srcdir)/gtktypebuiltins_ids.c
+ make $(srcdir)/gtktypebuiltins_vars.c
make $(srcdir)/gtktypebuiltins.h
+# generate gtk.defs file from gtk-boxed.defs and gcc -E
$(srcdir)/gtk.defs: @MAINT@
$(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \
awk -f $(srcdir)/makeenums.awk - defs > $@
cat $(srcdir)/gtk-boxed.defs >> $@
-
-$(srcdir)/gtktypebuiltins1.c: @MAINT@
- $(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \
- awk -f $(srcdir)/makeenums.awk - arrays > $@
-$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el
- $(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el id $< $@
+# generate type identifier header (GTK_TYPE_WIDGET_FLAGS)
+$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/maketypes.awk
+ awk -f $(srcdir)/maketypes.awk gtk.defs macros > $@
+
+# generate type identifier variables (GTK_TYPE_WIDGET_FLAGS)
+$(srcdir)/gtktypebuiltins_vars.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/maketypes.awk
+ awk -f $(srcdir)/maketypes.awk gtk.defs variables > $@
-$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el
- $(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el idmac $< $@
+# generate type entries for type-id registration
+$(srcdir)/gtktypebuiltins_ids.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/maketypes.awk
+ awk -f $(srcdir)/maketypes.awk gtk.defs entries > $@
+
+# generate enum value arrays from gcc -E
+$(srcdir)/gtktypebuiltins_evals.c: @MAINT@
+ $(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \
+ awk -f $(srcdir)/makeenums.awk - arrays > $@
# special remake rules
$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/makeenums.awk
$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/makeenums.h
$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/gtk-boxed.defs
-$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/gtk.defs
-$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/makeenums.awk
-$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/makeenums.h
-$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gtk.defs
-$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gentypeinfo.el
+$(srcdir)/gtktypebuiltins_vars.c: @MAINT@ $(srcdir)/maketypes.awk
+$(srcdir)/gtktypebuiltins_vars.c: @MAINT@ $(srcdir)/gtk.defs
+$(srcdir)/gtktypebuiltins_ids.c: @MAINT@ $(srcdir)/maketypes.awk
+$(srcdir)/gtktypebuiltins_ids.c: @MAINT@ $(srcdir)/gtk.defs
+$(srcdir)/gtktypebuiltins_evals.c: @MAINT@ $(srcdir)/makeenums.awk
+$(srcdir)/gtktypebuiltins_evals.c: @MAINT@ $(srcdir)/makeenums.h
+$(srcdir)/gtktypebuiltins_evals.c: @MAINT@ $(srcdir)/gtk.defs
+$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/maketypes.awk
$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs
-$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gentypeinfo.el
+$(srcdir)/makeenums.h: @MAINT@ $(srcdir)/gtk.h
+$(srcdir)/makeenums.h: @MAINT@ $(srcdir)/gtkprivate.h
libgtk_1_1_la_LDFLAGS = -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
testgtkrc2 \
gtkfeatures.h.in \
makeenums.awk \
+ maketypes.awk \
makeenums.h \
- runelisp \
- gentypeinfo.el \
- gtktypebuiltins1.c \
- gtktypebuiltins2.c \
+ gtktypebuiltins_vars.c \
+ gtktypebuiltins_ids.c \
+ gtktypebuiltins_evals.c \
gtk-boxed.defs \
gtk.defs \
test.xpm \
+++ /dev/null
-(require 'cl)
-
-;;; file access
-
-(defun read-file (name)
- (let ((buf (generate-new-buffer "infile"))
- (res nil))
- (save-excursion
- (set-buffer buf)
- (insert-file-contents name)
- (condition-case nil
- (while t
- (setq res (cons (read buf) res)))
- (end-of-file (reverse res))))))
-
-(defun setup-outfile ()
- (setq standard-output (generate-new-buffer "outfile")))
-
-(defun write-outfile (name)
- (save-excursion
- (set-buffer standard-output)
- (write-region (point-min) (point-max) name)))
-
-;;; string stunts
-
-(defun char-upper-case-p (ch)
- (eql (upcase ch) ch))
-
-(defun char-lower-case-p (ch)
- (eql (downcase ch) ch))
-
-(defun canonicalize (str)
- (if (symbolp str)
- (setq str (symbol-name str)))
- (let ((res nil)
- (start 0)
- (pos 0)
- (end (length str))
- (prevlower nil))
- (while (< pos end)
- (let ((ch (elt str pos)))
- (cond ((memq ch '(?- ?_))
- (setq res (cons (substring str start pos) res)
- prevlower nil
- pos (1+ pos)
- start pos))
- ((and (char-upper-case-p ch)
- prevlower)
- (setq res (cons (substring str start pos) res)
- start pos
- pos (1+ pos)
- prevlower nil))
- (t
- (setq pos (1+ pos)
- prevlower (char-lower-case-p ch))))))
- (reverse (mapcar 'downcase (cons (substring str start end) res)))))
-
-(defun syllables-to-string (syls del)
- (let ((res ""))
- (while syls
- (setq res (format "%s%s%s" res (car syls)
- (if (cdr syls) del ""))
- syls (cdr syls)))
- res))
-
-(defun macroname (canon)
- (syllables-to-string (mapcar 'upcase canon) "_"))
-
-(defun funcname (canon)
- (syllables-to-string canon "_"))
-
-(defun typename (canon)
- (syllables-to-string (mapcar 'capitalize canon) ""))
-
-(defun scmname (canon)
- (syllables-to-string canon "-"))
-
-(defun short-name (canon)
- (if (equal (car canon) "gtk") (cdr canon) canon))
-
-;;; Code generation
-
-(defun printf (&rest args)
- (princ (apply 'format args)))
-
-(defun interestingp (form)
- (and (listp form)
- (memq (car form) '(define-enum define-flags define-boxed))))
-
-(defun map-interesting (func defs)
- (mapcar #'(lambda (form)
- (if (interestingp form)
- (funcall func form)))
- defs))
-
-(defun emit-idmacs (defs)
- (let ((i 0))
- (map-interesting
- #'(lambda (form)
- (let ((name (canonicalize (cadr form))))
- (printf "#define GTK_TYPE_%s (gtk_type_builtins[%d])\n"
- (macroname (short-name name)) i))
- (setq i (1+ i)))
- defs)
- (printf "#define GTK_TYPE_NUM_BUILTINS %d\n" i)))
-
-(defun emit-ids (defs)
- (map-interesting
- #'(lambda (form)
- (printf " { %S, %s, %s%s },\n"
- (symbol-name (cadr form))
- (case (car form)
- ((define-enum) "GTK_TYPE_ENUM")
- ((define-flags) "GTK_TYPE_FLAGS")
- ((define-boxed) "GTK_TYPE_BOXED"))
- (case (car form)
- ((define-enum) "enum_values_")
- ((define-flags) "enum_values_")
- ((define-boxed) "NULL"))
- (case (car form)
- ((define-enum) (symbol-name (cadr form)))
- ((define-flags) (symbol-name (cadr form)))
- ((define-boxed) ""))))
- defs))
-
-
-
-(if (< (length command-line-args-left) 3)
- (error "args: op def-file output-file"))
-
-(setq op (intern (car command-line-args-left)))
-(setq defs (read-file (cadr command-line-args-left)))
-(setq outfile (caddr command-line-args-left))
-(setq command-line-args-left nil)
-
-(setup-outfile)
-(printf "/* generated by gentypeinfo from \"gtk.defs\" */\n\n")
-(case op
- ((idmac)
- (emit-idmacs defs))
- ((id)
- (emit-ids defs))
- (else
- (error "supported ops are: idmac id")))
-(write-outfile outfile)
gtk_accel_group_ref
gtk_accel_group_unref)
+(define-boxed GtkSelectionData
+)
+
(define-boxed GtkStyle
gtk_style_ref
gtk_style_unref)
;; generated by makeenums.awk ; -*- scheme -*-
+; enumerations from "gdktypes.h"
+
(define-enum GdkWindowType
(root GDK_WINDOW_ROOT)
(toplevel GDK_WINDOW_TOPLEVEL)
(round GDK_JOIN_ROUND)
(bevel GDK_JOIN_BEVEL))
+; enumerations from "gdktypes.h"
+
(define-enum GdkFilterReturn
(continue GDK_FILTER_CONTINUE)
(translate GDK_FILTER_TRANSLATE)
(button3-mask GDK_BUTTON3_MASK)
(button4-mask GDK_BUTTON4_MASK)
(button5-mask GDK_BUTTON5_MASK)
- (after-mask GDK_AFTER_MASK)
(modifier-mask GDK_MODIFIER_MASK))
(define-enum GdkSubwindowMode
(out GDK_OVERLAP_RECTANGLE_OUT)
(part GDK_OVERLAP_RECTANGLE_PART))
+; enumerations from "gdkprivate.h"
+
+(define-flags GdkDebugFlag
+ (misc GDK_DEBUG_MISC)
+ (events GDK_DEBUG_EVENTS)
+ (dnd GDK_DEBUG_DND)
+ (color-context GDK_DEBUG_COLOR_CONTEXT)
+ (xim GDK_DEBUG_XIM))
+
+; enumerations from "gtkenums.h"
+
(define-flags GtkAccelFlags
(visible GTK_ACCEL_VISIBLE)
(signal-visible GTK_ACCEL_SIGNAL_VISIBLE)
(last GTK_RUN_LAST)
(both GTK_RUN_BOTH)
(mask GTK_RUN_MASK)
- (no-recurse GTK_RUN_NO_RECURSE))
+ (no-recurse GTK_RUN_NO_RECURSE)
+ (action GTK_RUN_ACTION))
(define-enum GtkStateType
(normal GTK_STATE_NORMAL)
(dialog GTK_WINDOW_DIALOG)
(popup GTK_WINDOW_POPUP))
+; enumerations from "gtktypeutils.h"
+
(define-enum GtkFundamentalType
(invalid GTK_TYPE_INVALID)
(none GTK_TYPE_NONE)
(c-callback GTK_TYPE_C_CALLBACK)
(object GTK_TYPE_OBJECT))
+; enumerations from "gtkdebug.h"
+
(define-flags GtkDebugFlag
(objects GTK_DEBUG_OBJECTS)
(misc GTK_DEBUG_MISC)
(signals GTK_DEBUG_SIGNALS))
+; enumerations from "gtkobject.h"
+
(define-flags GtkObjectFlags
(destroyed GTK_DESTROYED)
(floating GTK_FLOATING)
(mask GTK_ARG_MASK)
(readwrite GTK_ARG_READWRITE))
+; enumerations from "gtkwidget.h"
+
(define-flags GtkWidgetFlags
(toplevel GTK_TOPLEVEL)
(no-window GTK_NO_WINDOW)
(rc-style GTK_RC_STYLE)
(basic GTK_BASIC))
+; enumerations from "gtkprivate.h"
+
(define-flags GtkPrivateFlags
(user-style PRIVATE_GTK_USER_STYLE)
(redraw-pending PRIVATE_GTK_REDRAW_PENDING)
(has-shape-mask PRIVATE_GTK_HAS_SHAPE_MASK)
(in-reparent PRIVATE_GTK_IN_REPARENT))
-(define-flags GdkDebugFlag
- (misc GDK_DEBUG_MISC)
- (events GDK_DEBUG_EVENTS)
- (dnd GDK_DEBUG_DND)
- (color-context GDK_DEBUG_COLOR_CONTEXT)
- (xim GDK_DEBUG_XIM))
-
;; -*- scheme -*-
gtk_accel_group_ref
gtk_accel_group_unref)
+(define-boxed GtkSelectionData
+)
+
(define-boxed GtkStyle
gtk_style_ref
gtk_style_unref)
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags,
gpointer func_data);
typedef void (*GtkSignalRemoveAccelerator) (GtkObject *object,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
gpointer func_data);
/* --- variables --- */
static GtkAccelEntry*
gtk_accel_group_lookup (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
GtkAccelEntry key_entry = { 0 };
gboolean
gtk_accel_group_activate (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
gboolean
gtk_accel_groups_activate (GtkObject *object,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (GTK_IS_OBJECT (object), FALSE);
void
gtk_accel_group_lock_entry (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
void
gtk_accel_group_unlock_entry (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
GtkAccelEntry*
gtk_accel_group_get_entry (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
g_return_val_if_fail (accel_group != NULL, 0);
void
gtk_accel_group_add (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags,
GtkObject *object,
const gchar *accel_signal)
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags)
{
GtkAccelEntry *entry;
void
gtk_accel_group_remove (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkObject *object)
{
GtkAccelEntry *entry;
gtk_accel_group_handle_remove (GtkObject *object,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods)
+ GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
guint
gtk_accel_group_create_add (GtkType class_type,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
guint handler_offset)
{
g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
return gtk_signal_new ("add-accelerator",
- run_type,
+ signal_flags,
class_type,
handler_offset,
gtk_accel_group_marshal_add,
GTK_TYPE_NONE, 5,
GTK_TYPE_UINT,
- GTK_TYPE_BOXED,
+ GTK_TYPE_ACCEL_GROUP,
GTK_TYPE_UINT,
- GTK_TYPE_UINT,
- GTK_TYPE_ENUM);
+ GTK_TYPE_GDK_MODIFIER_TYPE,
+ GTK_TYPE_ACCEL_FLAGS);
}
guint
gtk_accel_group_create_remove (GtkType class_type,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
guint handler_offset)
{
g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
return gtk_signal_new ("remove-accelerator",
- run_type,
+ signal_flags,
class_type,
handler_offset,
gtk_accel_group_marshal_remove,
GTK_TYPE_NONE, 3,
- GTK_TYPE_BOXED,
+ GTK_TYPE_ACCEL_GROUP,
GTK_TYPE_UINT,
- GTK_TYPE_UINT);
+ GTK_TYPE_GDK_MODIFIER_TYPE);
}
void
(string[6] == '>'));
}
-static inline gboolean
-is_after (const gchar *string)
-{
- return ((string[0] == '<') &&
- (string[1] == 'a' || string[1] == 'A') &&
- (string[2] == 'f' || string[2] == 'F') &&
- (string[3] == 't' || string[3] == 'T') &&
- (string[4] == 'e' || string[4] == 'E') &&
- (string[5] == 'r' || string[5] == 'R') &&
- (string[6] == '>'));
-}
-
static inline gboolean
is_control (const gchar *string)
{
void
gtk_accelerator_parse (const gchar *accelerator,
guint *accelerator_key,
- guint *accelerator_mods)
+ GdkModifierType*accelerator_mods)
{
guint keyval;
- guint mods;
+ GdkModifierType mods;
gint len;
if (accelerator_key)
len -= 7;
mods |= GDK_SHIFT_MASK;
}
- else if (len >= 7 && is_after (accelerator))
- {
- accelerator += 7;
- len -= 7;
- mods |= GDK_AFTER_MASK;
- }
else if (len >= 6 && is_shft (accelerator))
{
accelerator += 6;
gchar*
gtk_accelerator_name (guint accelerator_key,
- guint accelerator_mods)
+ GdkModifierType accelerator_mods)
{
static const gchar text_shift[] = "<Shift>";
static const gchar text_control[] = "<Control>";
static const gchar text_mod3[] = "<Mod3>";
static const gchar text_mod4[] = "<Mod4>";
static const gchar text_mod5[] = "<Mod5>";
- static const gchar text_after[] = "<After>";
guint l;
gchar *keyval_name;
gchar *accelerator;
l += sizeof (text_mod4) - 1;
if (accelerator_mods & GDK_MOD5_MASK)
l += sizeof (text_mod5) - 1;
- if (accelerator_mods & GDK_AFTER_MASK)
- l += sizeof (text_after) - 1;
l += strlen (keyval_name);
accelerator = g_new (gchar, l + 1);
strcpy (accelerator + l, text_mod5);
l += sizeof (text_mod5) - 1;
}
- if (accelerator_mods & GDK_AFTER_MASK)
- {
- strcpy (accelerator + l, text_after);
- l += sizeof (text_after) - 1;
- }
strcpy (accelerator + l, keyval_name);
return accelerator;
struct _GtkAccelGroup
{
- guint ref_count;
- guint lock_count;
- guint modifier_mask;
- GSList *attach_objects;
+ guint ref_count;
+ guint lock_count;
+ GdkModifierType modifier_mask;
+ GSList *attach_objects;
};
struct _GtkAccelEntry
*/
GtkAccelGroup *accel_group;
guint accelerator_key;
- guint accelerator_mods;
+ GdkModifierType accelerator_mods;
GtkAccelFlags accel_flags;
GtkObject *object;
void gtk_accel_group_unref (GtkAccelGroup *accel_group);
gboolean gtk_accel_group_activate (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
gboolean gtk_accel_groups_activate (GtkObject *object,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
void gtk_accel_group_attach (GtkAccelGroup *accel_group,
GtkObject *object);
void gtk_accel_group_detach (GtkAccelGroup *accel_group,
*/
GtkAccelEntry* gtk_accel_group_get_entry (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
void gtk_accel_group_lock_entry (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
void gtk_accel_group_unlock_entry (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
void gtk_accel_group_add (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags,
GtkObject *object,
const gchar *accel_signal);
void gtk_accel_group_remove (GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkObject *object);
/* Accelerator Signals
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags);
void gtk_accel_group_handle_remove (GtkObject *object,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
guint gtk_accel_group_create_add (GtkType class_type,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
guint handler_offset);
guint gtk_accel_group_create_remove (GtkType class_type,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
guint handler_offset);
void gtk_accel_group_marshal_add (GtkObject *object,
GtkSignalFunc func,
/* Accelerators
*/
-gboolean gtk_accelerator_valid (guint keyval,
- guint modifiers);
-void gtk_accelerator_parse (const gchar *accelerator,
- guint *accelerator_key,
- guint *accelerator_mods);
-gchar* gtk_accelerator_name (guint accelerator_key,
- guint accelerator_mods);
-void gtk_accelerator_set_default_mod_mask (guint default_mod_mask);
-guint gtk_accelerator_get_default_mod_mask (void);
+gboolean gtk_accelerator_valid (guint keyval,
+ GdkModifierType modifiers);
+void gtk_accelerator_parse (const gchar *accelerator,
+ guint *accelerator_key,
+ GdkModifierType *accelerator_mods);
+gchar* gtk_accelerator_name (guint accelerator_key,
+ GdkModifierType accelerator_mods);
+void gtk_accelerator_set_default_mod_mask (GdkModifierType default_mod_mask);
+guint gtk_accelerator_get_default_mod_mask (void);
/* --- defines --- */
-#define BINDING_MOD_MASK() (gtk_accelerator_get_default_mod_mask () | GDK_AFTER_MASK)
+#define BINDING_MOD_MASK() (gtk_accelerator_get_default_mod_mask ())
/* --- variables --- */
GtkSignalQuery *query;
guint signal_id;
GtkArg *params = NULL;
+ gchar *accelerator = NULL;
signal_id = gtk_signal_lookup (sig->signal_name, GTK_OBJECT_TYPE (object));
if (!signal_id)
{
- gchar *accelerator;
-
accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
"could not find signal \"%s\" in the `%s' class ancestry",
query->return_val != GTK_TYPE_NONE ||
!binding_compose_params (sig->args, query, ¶ms))
{
- gchar *accelerator;
-
accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
"signature mismatch for signal \"%s\" in the `%s' class ancestry",
accelerator,
sig->signal_name,
gtk_type_name (GTK_OBJECT_TYPE (object)));
- g_free (accelerator);
- g_free (query);
- continue;
}
+ else if (!(query->signal_flags & GTK_RUN_ACTION))
+ {
+ accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
+ g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
+ "signal \"%s\" in the `%s' class ancestry cannot be used for action emissions",
+ entry->binding_set->set_name,
+ accelerator,
+ sig->signal_name,
+ gtk_type_name (GTK_OBJECT_TYPE (object)));
+ }
+ g_free (accelerator);
g_free (query);
+ if (accelerator)
+ continue;
gtk_signal_emitv (object, signal_id, params);
g_free (params);
NEED_RESIZE,
FOREACH,
FOCUS,
+ SET_FOCUS_CHILD,
LAST_SIGNAL
};
enum {
GtkWidget *widget);
static void gtk_container_remove_unimplemented (GtkContainer *container,
GtkWidget *widget);
-static gint gtk_real_container_need_resize (GtkContainer *container);
-static gint gtk_real_container_focus (GtkContainer *container,
+static gint gtk_container_real_need_resize (GtkContainer *container);
+static gint gtk_container_real_focus (GtkContainer *container,
GtkDirectionType direction);
+static void gtk_container_real_set_focus_child (GtkContainer *container,
+ GtkWidget *widget);
static gint gtk_container_focus_tab (GtkContainer *container,
GList *children,
GtkDirectionType direction);
gtk_container_marshal_signal_3,
GTK_TYPE_DIRECTION_TYPE, 1,
GTK_TYPE_DIRECTION_TYPE);
-
+ container_signals[SET_FOCUS_CHILD] =
+ gtk_signal_new ("set-focus-child",
+ GTK_RUN_FIRST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (GtkContainerClass, set_focus_child),
+ gtk_container_marshal_signal_1,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_WIDGET);
gtk_object_class_add_signals (object_class, container_signals, LAST_SIGNAL);
object_class->destroy = gtk_container_destroy;
class->add = gtk_container_add_unimplemented;
class->remove = gtk_container_remove_unimplemented;
- class->need_resize = gtk_real_container_need_resize;
+ class->need_resize = gtk_container_real_need_resize;
class->foreach = NULL;
- class->focus = gtk_real_container_focus;
+ class->focus = gtk_container_real_focus;
+ class->set_focus_child = gtk_container_real_set_focus_child;
}
static void
GtkCallback callback,
gpointer callback_data)
{
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (container));
+ g_return_if_fail (callback != NULL);
+
gtk_signal_emit (GTK_OBJECT (container),
container_signals[FOREACH],
callback, callback_data);
gpointer callback_data,
GtkDestroyNotify notify)
{
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (container));
+
if (marshal)
{
GtkForeachData fdata;
gtk_container_foreach (container, gtk_container_foreach_unmarshal, &fdata);
}
else
- gtk_container_foreach (container, callback, &callback_data);
-
- notify (callback_data);
+ {
+ g_return_if_fail (callback != NULL);
+
+ gtk_container_foreach (container, callback, &callback_data);
+ }
+
+ if (notify)
+ notify (callback_data);
}
gint
GtkDirectionType direction)
{
gint return_val;
+
+ g_return_val_if_fail (container != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
gtk_signal_emit (GTK_OBJECT (container),
container_signals[FOCUS],
return return_val;
}
+void
+gtk_container_set_focus_child (GtkContainer *container,
+ GtkWidget *widget)
+{
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (container));
+ if (widget)
+ g_return_if_fail (GTK_IS_WIDGET (container));
+
+ gtk_signal_emit (GTK_OBJECT (container), container_signals[SET_FOCUS_CHILD], widget);
+}
+
GList*
gtk_container_children (GtkContainer *container)
{
}
void
-gtk_container_set_focus_child (GtkContainer *container,
- GtkWidget *child)
+gtk_container_real_set_focus_child (GtkContainer *container,
+ GtkWidget *child)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
}
static gint
-gtk_real_container_need_resize (GtkContainer *container)
+gtk_container_real_need_resize (GtkContainer *container)
{
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
}
static gint
-gtk_real_container_focus (GtkContainer *container,
+gtk_container_real_focus (GtkContainer *container,
GtkDirectionType direction)
{
GList *children;
{
GtkWidgetClass parent_class;
- void (* add) (GtkContainer *container,
- GtkWidget *widget);
- void (* remove) (GtkContainer *container,
- GtkWidget *widget);
- gint (* need_resize) (GtkContainer *container);
- void (* foreach) (GtkContainer *container,
- GtkCallback callback,
- gpointer callbabck_data);
- gint (* focus) (GtkContainer *container,
- GtkDirectionType direction);
+ void (* add) (GtkContainer *container,
+ GtkWidget *widget);
+ void (* remove) (GtkContainer *container,
+ GtkWidget *widget);
+ gint (* need_resize) (GtkContainer *container);
+ void (* foreach) (GtkContainer *container,
+ GtkCallback callback,
+ gpointer callbabck_data);
+ gint (* focus) (GtkContainer *container,
+ GtkDirectionType direction);
+ void (* set_focus_child) (GtkContainer *container,
+ GtkWidget *widget);
};
GtkAdjustment *adjustment);
void gtk_container_set_focus_hadjustment (GtkContainer *container,
GtkAdjustment *adjustment);
+
G_NV (GTK_RUN_LAST, last, 0x2),
G_NV (GTK_RUN_BOTH, both, 0x3),
G_NV (GTK_RUN_MASK, mask, 0xF),
- G_NV (GTK_RUN_NO_RECURSE, no-recurse, 0x10)
+ G_NV (GTK_RUN_NO_RECURSE, no-recurse, 0x10),
+ G_NV (GTK_RUN_ACTION, action, 0x20)
} G_FLAGS (GtkSignalRunType);
/* Widget states */
gtk_object_add_arg_type ("GtkFrame::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
gtk_object_add_arg_type ("GtkFrame::label_xalign", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_LABEL_XALIGN);
gtk_object_add_arg_type ("GtkFrame::label_yalign", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_LABEL_YALIGN);
- gtk_object_add_arg_type ("GtkFrame::shadow", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_SHADOW);
+ gtk_object_add_arg_type ("GtkFrame::shadow", GTK_TYPE_SHADOW_TYPE, GTK_ARG_READWRITE, ARG_SHADOW);
object_class->finalize = gtk_frame_finalize;
parent_class = gtk_type_class (gtk_misc_get_type ());
gtk_object_add_arg_type ("GtkLabel::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
- gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_JUSTIFY);
+ gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
object_class->finalize = gtk_label_finalize;
}
guint
-gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *class,
- const gchar *name,
- GtkSignalMarshaller marshaller,
- GtkType return_val,
- guint nparams,
- ...)
+gtk_object_class_user_signal_new (GtkObjectClass *class,
+ const gchar *name,
+ GtkSignalRunType signal_flags,
+ GtkSignalMarshaller marshaller,
+ GtkType return_val,
+ guint nparams,
+ ...)
{
GtkType *params;
guint i;
params = NULL;
signal_id = gtk_signal_newv (name,
- GTK_RUN_NO_RECURSE,
+ signal_flags,
class->type,
0,
marshaller,
return signal_id;
}
+guint
+gtk_object_class_user_signal_newv (GtkObjectClass *class,
+ const gchar *name,
+ GtkSignalRunType signal_flags,
+ GtkSignalMarshaller marshaller,
+ GtkType return_val,
+ guint nparams,
+ GtkType *params)
+{
+ guint signal_id;
+
+ g_return_val_if_fail (class != NULL, 0);
+
+ if (nparams > 0)
+ g_return_val_if_fail (params != NULL, 0);
+
+ signal_id = gtk_signal_newv (name,
+ signal_flags,
+ class->type,
+ 0,
+ marshaller,
+ return_val,
+ nparams,
+ params);
+
+ if (signal_id)
+ gtk_object_class_add_signals (class, &signal_id, 1);
+
+ return signal_id;
+}
+
/*****************************************
* gtk_object_sink:
*
/* Append a user defined signal without default handler to a class.
*/
-guint gtk_object_class_add_user_signal (GtkObjectClass *klass,
- const gchar *name,
- GtkSignalMarshaller marshaller,
- GtkType return_val,
- guint nparams,
+guint gtk_object_class_user_signal_new (GtkObjectClass *klass,
+ const gchar *name,
+ GtkSignalRunType signal_flags,
+ GtkSignalMarshaller marshaller,
+ GtkType return_val,
+ guint nparams,
+ ...);
+guint gtk_object_class_user_signal_newv (GtkObjectClass *klass,
+ const gchar *name,
+ GtkSignalRunType signal_flags,
+ GtkSignalMarshaller marshaller,
+ GtkType return_val,
+ guint nparams,
+ GtkType *params);
+/* Outdated */
+guint gtk_object_class_add_user_signal (GtkObjectClass *klass,
+ const gchar *name,
+ GtkSignalMarshaller marshaller,
+ GtkType return_val,
+ guint nparams,
...);
-guint gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *klass,
- const gchar *name,
- GtkSignalMarshaller marshaller,
- GtkType return_val,
- guint nparams,
- ...);
GtkObject* gtk_object_new (GtkType type,
...);
data->length = -1;
}
}
+
+
+GtkSelectioData*
+gtk_selection_data_copy (GtkSelectionData *data)
+{
+ GtkSelectionData *new_data;
+
+ g_return_val_if_fail (data != NULL, NULL);
+
+ new_data = g_new (GtkSelectionData, 1);
+ *new_data = *data;
+
+ return new_data;
+}
+
+void
+gtk_selection_data_free (GtkSelectionData *data)
+{
+ g_return_if_fail (data != NULL);
+
+ g_free (data);
+}
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
typedef struct _GtkSelectionData GtkSelectioData;
GdkEventSelection *event);
gint gtk_selection_property_notify (GtkWidget *widget,
GdkEventProperty *event);
+GtkSelectioData *gtk_selection_data_copy (GtkSelectionData *data);
+void gtk_selection_data_free (GtkSelectionData *data);
GtkType object_type;
gchar *name;
guint function_offset;
- GtkSignalRunType run_type;
+ GtkSignalRunType signal_flags;
GtkSignalMarshaller marshaller;
GtkType return_val;
GtkType *params;
GtkArg *params;
GtkType *param_types;
GtkType return_val;
- GtkSignalRunType run_type;
+ GtkSignalRunType signal_flags;
guint nparams;
guint signal_id;
};
guint
gtk_signal_newv (const gchar *r_name,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
}
if (return_val != GTK_TYPE_NONE &&
- (run_type & GTK_RUN_BOTH) == GTK_RUN_FIRST)
+ (signal_flags & GTK_RUN_BOTH) == GTK_RUN_FIRST)
{
g_warning ("gtk_signal_newv(): signal \"%s\" with return value `%s' excludes GTK_RUN_LAST",
name, gtk_type_name (return_val));
signal->object_type = object_type;
signal->name = name;
signal->function_offset = function_offset;
- signal->run_type = run_type;
+ signal->signal_flags = signal_flags;
signal->marshaller = marshaller;
signal->return_val = return_val;
signal->nparams = nparams;
guint
gtk_signal_new (const gchar *name,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
params = NULL;
signal_id = gtk_signal_newv (name,
- run_type,
+ signal_flags,
object_type,
function_offset,
marshaller,
query->signal_id = signal_id;
query->signal_name = signal->name;
query->is_user_signal = signal->function_offset == 0;
- query->run_type = signal->run_type;
+ query->signal_flags = signal->signal_flags;
query->return_val = signal->return_val;
query->nparams = signal->nparams;
query->params = signal->params;
object);
#endif /* G_ENABLE_DEBUG */
- if ((signal->run_type & GTK_RUN_NO_RECURSE) &&
+ if ((signal->signal_flags & GTK_RUN_NO_RECURSE) &&
gtk_emission_check (current_emissions, object, signal_id))
{
gtk_emission_add (&restart_emissions, object, signal_id);
gtk_emission_add (¤t_emissions, object, signal_id);
emission_restart:
- if (GTK_RUN_TYPE (signal->run_type) != GTK_RUN_LAST && signal->function_offset != 0)
+ if (GTK_RUN_TYPE (signal->signal_flags) != GTK_RUN_LAST && signal->function_offset != 0)
{
signal_func_offset = (guchar**) ((guchar*) object->klass +
signal->function_offset);
info.param_types = signal->params;
info.return_val = signal->return_val;
info.nparams = signal->nparams;
- info.run_type = signal->run_type;
+ info.signal_flags = signal->signal_flags;
info.signal_id = signal_id;
switch (gtk_handlers_run (handlers, &info, FALSE))
else
info.object = NULL;
- if (GTK_RUN_TYPE (signal->run_type) != GTK_RUN_FIRST && signal->function_offset != 0)
+ if (GTK_RUN_TYPE (signal->signal_flags) != GTK_RUN_FIRST && signal->function_offset != 0)
{
signal_func_offset = (guchar**) ((guchar*) object->klass +
signal->function_offset);
info.param_types = signal->params;
info.return_val = signal->return_val;
info.nparams = signal->nparams;
- info.run_type = signal->run_type;
+ info.signal_flags = signal->signal_flags;
info.signal_id = signal_id;
}
switch (gtk_handlers_run (handlers, &info, TRUE))
gtk_emission_remove (¤t_emissions, object, signal_id);
- if (signal->run_type & GTK_RUN_NO_RECURSE)
+ if (signal->signal_flags & GTK_RUN_NO_RECURSE)
gtk_emission_remove (&restart_emissions, object, signal_id);
gtk_object_unref (object);
gtk_emission_remove (&stop_emissions, info->object,
info->signal_id);
- if (info->run_type & GTK_RUN_NO_RECURSE)
+ if (info->signal_flags & GTK_RUN_NO_RECURSE)
gtk_emission_remove (&restart_emissions, info->object,
info->signal_id);
gtk_signal_handler_unref (handlers, info->object);
return EMISSION_DONE;
}
- else if ((info->run_type & GTK_RUN_NO_RECURSE) &&
+ else if ((info->signal_flags & GTK_RUN_NO_RECURSE) &&
gtk_emission_check (restart_emissions, info->object,
info->signal_id))
{
guint signal_id;
const gchar *signal_name;
guint is_user_signal : 1;
- GtkSignalRunType run_type;
+ GtkSignalRunType signal_flags;
GtkType return_val;
guint nparams;
const GtkType *params;
void gtk_signal_init (void);
guint gtk_signal_new (const gchar *name,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
guint nparams,
...);
guint gtk_signal_newv (const gchar *name,
- GtkSignalRunType run_type,
+ GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
GTK_TYPE_WIDGET,
GTK_TYPE_STRING,
GTK_TYPE_STRING,
- GTK_TYPE_BOXED);
+ GTK_TYPE_GDK_EVENT);
gtk_object_class_add_signals (object_class, tips_query_signals, SIGNAL_LAST);
object_class->destroy = gtk_tips_query_destroy;
/* --- type macros --- */
-#define GTK_TIPS_QUERY(obj) (GTK_CHECK_CAST (obj, gtk_tips_query_get_type (), GtkTipsQuery))
-#define GTK_TIPS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, gtk_tips_query_get_type (), GtkTipsQueryClass))
-#define GTK_IS_TIPS_QUERY(obj) (GTK_CHECK_TYPE (obj, gtk_tips_query_get_type ()))
+#define GTK_TYPE_TIPS_QUERY (gtk_tips_query_get_type ())
+#define GTK_TIPS_QUERY(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_TIPS_QUERY, GtkTipsQuery))
+#define GTK_TIPS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TIPS_QUERY, GtkTipsQueryClass))
+#define GTK_IS_TIPS_QUERY(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_TIPS_QUERY))
+#define GTK_IS_TIPS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TIPS_QUERY))
/* --- typedefs --- */
-/* generated by gentypeinfo from "gtk.defs" */
+/* type macros, generated by maketypes.awk */
-#define GTK_TYPE_GDK_WINDOW_TYPE (gtk_type_builtins[0])
-#define GTK_TYPE_GDK_WINDOW_CLASS (gtk_type_builtins[1])
-#define GTK_TYPE_GDK_IMAGE_TYPE (gtk_type_builtins[2])
-#define GTK_TYPE_GDK_VISUAL_TYPE (gtk_type_builtins[3])
-#define GTK_TYPE_GDK_FONT_TYPE (gtk_type_builtins[4])
-#define GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE (gtk_type_builtins[5])
-#define GTK_TYPE_GDK_WINDOW_HINTS (gtk_type_builtins[6])
-#define GTK_TYPE_GDK_FUNCTION (gtk_type_builtins[7])
-#define GTK_TYPE_GDK_FILL (gtk_type_builtins[8])
-#define GTK_TYPE_GDK_FILL_RULE (gtk_type_builtins[9])
-#define GTK_TYPE_GDK_LINE_STYLE (gtk_type_builtins[10])
-#define GTK_TYPE_GDK_CAP_STYLE (gtk_type_builtins[11])
-#define GTK_TYPE_GDK_JOIN_STYLE (gtk_type_builtins[12])
-#define GTK_TYPE_GDK_FILTER_RETURN (gtk_type_builtins[13])
-#define GTK_TYPE_GDK_VISIBILITY_STATE (gtk_type_builtins[14])
-#define GTK_TYPE_GDK_EVENT_TYPE (gtk_type_builtins[15])
-#define GTK_TYPE_GDK_EVENT_MASK (gtk_type_builtins[16])
-#define GTK_TYPE_GDK_NOTIFY_TYPE (gtk_type_builtins[17])
-#define GTK_TYPE_GDK_CROSSING_MODE (gtk_type_builtins[18])
-#define GTK_TYPE_GDK_MODIFIER_TYPE (gtk_type_builtins[19])
-#define GTK_TYPE_GDK_SUBWINDOW_MODE (gtk_type_builtins[20])
-#define GTK_TYPE_GDK_INPUT_CONDITION (gtk_type_builtins[21])
-#define GTK_TYPE_GDK_STATUS (gtk_type_builtins[22])
-#define GTK_TYPE_GDK_BYTE_ORDER (gtk_type_builtins[23])
-#define GTK_TYPE_GDK_GCVALUES_MASK (gtk_type_builtins[24])
-#define GTK_TYPE_GDK_SELECTION (gtk_type_builtins[25])
-#define GTK_TYPE_GDK_PROPERTY_STATE (gtk_type_builtins[26])
-#define GTK_TYPE_GDK_PROP_MODE (gtk_type_builtins[27])
-#define GTK_TYPE_GDK_DND_TYPE (gtk_type_builtins[28])
-#define GTK_TYPE_GDK_INPUT_SOURCE (gtk_type_builtins[29])
-#define GTK_TYPE_GDK_INPUT_MODE (gtk_type_builtins[30])
-#define GTK_TYPE_GDK_AXIS_USE (gtk_type_builtins[31])
-#define GTK_TYPE_GDK_TARGET (gtk_type_builtins[32])
-#define GTK_TYPE_GDK_SELECTION_TYPE (gtk_type_builtins[33])
-#define GTK_TYPE_GDK_EXTENSION_MODE (gtk_type_builtins[34])
-#define GTK_TYPE_GDK_WMDECORATION (gtk_type_builtins[35])
-#define GTK_TYPE_GDK_WMFUNCTION (gtk_type_builtins[36])
-#define GTK_TYPE_GDK_COLOR_CONTEXT_MODE (gtk_type_builtins[37])
-#define GTK_TYPE_GDK_OVERLAP_TYPE (gtk_type_builtins[38])
-#define GTK_TYPE_ACCEL_FLAGS (gtk_type_builtins[39])
-#define GTK_TYPE_ARROW_TYPE (gtk_type_builtins[40])
-#define GTK_TYPE_ATTACH_OPTIONS (gtk_type_builtins[41])
-#define GTK_TYPE_BUTTON_BOX_STYLE (gtk_type_builtins[42])
-#define GTK_TYPE_CURVE_TYPE (gtk_type_builtins[43])
-#define GTK_TYPE_DIRECTION_TYPE (gtk_type_builtins[44])
-#define GTK_TYPE_JUSTIFICATION (gtk_type_builtins[45])
-#define GTK_TYPE_MATCH_TYPE (gtk_type_builtins[46])
-#define GTK_TYPE_MENU_FACTORY_TYPE (gtk_type_builtins[47])
-#define GTK_TYPE_METRIC_TYPE (gtk_type_builtins[48])
-#define GTK_TYPE_ORIENTATION (gtk_type_builtins[49])
-#define GTK_TYPE_PACK_TYPE (gtk_type_builtins[50])
-#define GTK_TYPE_PATH_PRIORITY_TYPE (gtk_type_builtins[51])
-#define GTK_TYPE_PATH_TYPE (gtk_type_builtins[52])
-#define GTK_TYPE_POLICY_TYPE (gtk_type_builtins[53])
-#define GTK_TYPE_POSITION_TYPE (gtk_type_builtins[54])
-#define GTK_TYPE_PREVIEW_TYPE (gtk_type_builtins[55])
-#define GTK_TYPE_RELIEF_STYLE (gtk_type_builtins[56])
-#define GTK_TYPE_SCROLL_TYPE (gtk_type_builtins[57])
-#define GTK_TYPE_SELECTION_MODE (gtk_type_builtins[58])
-#define GTK_TYPE_SHADOW_TYPE (gtk_type_builtins[59])
-#define GTK_TYPE_SIGNAL_RUN_TYPE (gtk_type_builtins[60])
-#define GTK_TYPE_STATE_TYPE (gtk_type_builtins[61])
-#define GTK_TYPE_SUBMENU_DIRECTION (gtk_type_builtins[62])
-#define GTK_TYPE_SUBMENU_PLACEMENT (gtk_type_builtins[63])
-#define GTK_TYPE_TOOLBAR_STYLE (gtk_type_builtins[64])
-#define GTK_TYPE_TROUGH_TYPE (gtk_type_builtins[65])
-#define GTK_TYPE_UPDATE_TYPE (gtk_type_builtins[66])
-#define GTK_TYPE_VISIBILITY (gtk_type_builtins[67])
-#define GTK_TYPE_WINDOW_POSITION (gtk_type_builtins[68])
-#define GTK_TYPE_WINDOW_TYPE (gtk_type_builtins[69])
-#define GTK_TYPE_FUNDAMENTAL_TYPE (gtk_type_builtins[70])
-#define GTK_TYPE_DEBUG_FLAG (gtk_type_builtins[71])
-#define GTK_TYPE_OBJECT_FLAGS (gtk_type_builtins[72])
-#define GTK_TYPE_ARG_FLAGS (gtk_type_builtins[73])
-#define GTK_TYPE_WIDGET_FLAGS (gtk_type_builtins[74])
-#define GTK_TYPE_PRIVATE_FLAGS (gtk_type_builtins[75])
-#define GTK_TYPE_GDK_DEBUG_FLAG (gtk_type_builtins[76])
-#define GTK_TYPE_ACCEL_GROUP (gtk_type_builtins[77])
-#define GTK_TYPE_STYLE (gtk_type_builtins[78])
-#define GTK_TYPE_GDK_COLORMAP (gtk_type_builtins[79])
-#define GTK_TYPE_GDK_VISUAL (gtk_type_builtins[80])
-#define GTK_TYPE_GDK_FONT (gtk_type_builtins[81])
-#define GTK_TYPE_GDK_WINDOW (gtk_type_builtins[82])
-#define GTK_TYPE_GDK_EVENT (gtk_type_builtins[83])
-#define GTK_TYPE_GDK_COLOR (gtk_type_builtins[84])
-#define GTK_TYPE_NUM_BUILTINS 85
+extern GtkType GTK_TYPE_GDK_WINDOW_TYPE;
+extern GtkType GTK_TYPE_GDK_WINDOW_CLASS;
+extern GtkType GTK_TYPE_GDK_IMAGE_TYPE;
+extern GtkType GTK_TYPE_GDK_VISUAL_TYPE;
+extern GtkType GTK_TYPE_GDK_FONT_TYPE;
+extern GtkType GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE;
+extern GtkType GTK_TYPE_GDK_WINDOW_HINTS;
+extern GtkType GTK_TYPE_GDK_FUNCTION;
+extern GtkType GTK_TYPE_GDK_FILL;
+extern GtkType GTK_TYPE_GDK_FILL_RULE;
+extern GtkType GTK_TYPE_GDK_LINE_STYLE;
+extern GtkType GTK_TYPE_GDK_CAP_STYLE;
+extern GtkType GTK_TYPE_GDK_JOIN_STYLE;
+extern GtkType GTK_TYPE_GDK_FILTER_RETURN;
+extern GtkType GTK_TYPE_GDK_VISIBILITY_STATE;
+extern GtkType GTK_TYPE_GDK_EVENT_TYPE;
+extern GtkType GTK_TYPE_GDK_EVENT_MASK;
+extern GtkType GTK_TYPE_GDK_NOTIFY_TYPE;
+extern GtkType GTK_TYPE_GDK_CROSSING_MODE;
+extern GtkType GTK_TYPE_GDK_MODIFIER_TYPE;
+extern GtkType GTK_TYPE_GDK_SUBWINDOW_MODE;
+extern GtkType GTK_TYPE_GDK_INPUT_CONDITION;
+extern GtkType GTK_TYPE_GDK_STATUS;
+extern GtkType GTK_TYPE_GDK_BYTE_ORDER;
+extern GtkType GTK_TYPE_GDK_G_C_VALUES_MASK;
+extern GtkType GTK_TYPE_GDK_SELECTION;
+extern GtkType GTK_TYPE_GDK_PROPERTY_STATE;
+extern GtkType GTK_TYPE_GDK_PROP_MODE;
+extern GtkType GTK_TYPE_GDK_DND_TYPE;
+extern GtkType GTK_TYPE_GDK_INPUT_SOURCE;
+extern GtkType GTK_TYPE_GDK_INPUT_MODE;
+extern GtkType GTK_TYPE_GDK_AXIS_USE;
+extern GtkType GTK_TYPE_GDK_TARGET;
+extern GtkType GTK_TYPE_GDK_SELECTION_TYPE;
+extern GtkType GTK_TYPE_GDK_EXTENSION_MODE;
+extern GtkType GTK_TYPE_GDK_W_M_DECORATION;
+extern GtkType GTK_TYPE_GDK_W_M_FUNCTION;
+extern GtkType GTK_TYPE_GDK_COLOR_CONTEXT_MODE;
+extern GtkType GTK_TYPE_GDK_OVERLAP_TYPE;
+extern GtkType GTK_TYPE_GDK_DEBUG_FLAG;
+extern GtkType GTK_TYPE_ACCEL_FLAGS;
+extern GtkType GTK_TYPE_ARROW_TYPE;
+extern GtkType GTK_TYPE_ATTACH_OPTIONS;
+extern GtkType GTK_TYPE_BUTTON_BOX_STYLE;
+extern GtkType GTK_TYPE_CURVE_TYPE;
+extern GtkType GTK_TYPE_DIRECTION_TYPE;
+extern GtkType GTK_TYPE_JUSTIFICATION;
+extern GtkType GTK_TYPE_MATCH_TYPE;
+extern GtkType GTK_TYPE_MENU_FACTORY_TYPE;
+extern GtkType GTK_TYPE_METRIC_TYPE;
+extern GtkType GTK_TYPE_ORIENTATION;
+extern GtkType GTK_TYPE_PACK_TYPE;
+extern GtkType GTK_TYPE_PATH_PRIORITY_TYPE;
+extern GtkType GTK_TYPE_PATH_TYPE;
+extern GtkType GTK_TYPE_POLICY_TYPE;
+extern GtkType GTK_TYPE_POSITION_TYPE;
+extern GtkType GTK_TYPE_PREVIEW_TYPE;
+extern GtkType GTK_TYPE_RELIEF_STYLE;
+extern GtkType GTK_TYPE_SCROLL_TYPE;
+extern GtkType GTK_TYPE_SELECTION_MODE;
+extern GtkType GTK_TYPE_SHADOW_TYPE;
+extern GtkType GTK_TYPE_SIGNAL_RUN_TYPE;
+extern GtkType GTK_TYPE_STATE_TYPE;
+extern GtkType GTK_TYPE_SUBMENU_DIRECTION;
+extern GtkType GTK_TYPE_SUBMENU_PLACEMENT;
+extern GtkType GTK_TYPE_TOOLBAR_STYLE;
+extern GtkType GTK_TYPE_TROUGH_TYPE;
+extern GtkType GTK_TYPE_UPDATE_TYPE;
+extern GtkType GTK_TYPE_VISIBILITY;
+extern GtkType GTK_TYPE_WINDOW_POSITION;
+extern GtkType GTK_TYPE_WINDOW_TYPE;
+extern GtkType GTK_TYPE_FUNDAMENTAL_TYPE;
+extern GtkType GTK_TYPE_DEBUG_FLAG;
+extern GtkType GTK_TYPE_OBJECT_FLAGS;
+extern GtkType GTK_TYPE_ARG_FLAGS;
+extern GtkType GTK_TYPE_WIDGET_FLAGS;
+extern GtkType GTK_TYPE_PRIVATE_FLAGS;
+extern GtkType GTK_TYPE_ACCEL_GROUP;
+extern GtkType GTK_TYPE_SELECTION_DATA;
+extern GtkType GTK_TYPE_STYLE;
+extern GtkType GTK_TYPE_GDK_COLORMAP;
+extern GtkType GTK_TYPE_GDK_VISUAL;
+extern GtkType GTK_TYPE_GDK_FONT;
+extern GtkType GTK_TYPE_GDK_WINDOW;
+extern GtkType GTK_TYPE_GDK_EVENT;
+extern GtkType GTK_TYPE_GDK_COLOR;
+
+#define GTK_TYPE_NUM_BUILTINS (86)
+++ /dev/null
-/* generated by makeenums.awk */
-
-static GtkEnumValue enum_values_GdkWindowType[] = {
- { GDK_WINDOW_ROOT, "GDK_WINDOW_ROOT", "root" },
- { GDK_WINDOW_TOPLEVEL, "GDK_WINDOW_TOPLEVEL", "toplevel" },
- { GDK_WINDOW_CHILD, "GDK_WINDOW_CHILD", "child" },
- { GDK_WINDOW_DIALOG, "GDK_WINDOW_DIALOG", "dialog" },
- { GDK_WINDOW_TEMP, "GDK_WINDOW_TEMP", "temp" },
- { GDK_WINDOW_PIXMAP, "GDK_WINDOW_PIXMAP", "pixmap" },
- { GDK_WINDOW_FOREIGN, "GDK_WINDOW_FOREIGN", "foreign" },
-};
-static GtkEnumValue enum_values_GdkWindowClass[] = {
- { GDK_INPUT_OUTPUT, "GDK_INPUT_OUTPUT", "input-output" },
- { GDK_INPUT_ONLY, "GDK_INPUT_ONLY", "input-only" },
-};
-static GtkEnumValue enum_values_GdkImageType[] = {
- { GDK_IMAGE_NORMAL, "GDK_IMAGE_NORMAL", "normal" },
- { GDK_IMAGE_SHARED, "GDK_IMAGE_SHARED", "shared" },
- { GDK_IMAGE_FASTEST, "GDK_IMAGE_FASTEST", "fastest" },
-};
-static GtkEnumValue enum_values_GdkVisualType[] = {
- { GDK_VISUAL_STATIC_GRAY, "GDK_VISUAL_STATIC_GRAY", "static-gray" },
- { GDK_VISUAL_GRAYSCALE, "GDK_VISUAL_GRAYSCALE", "grayscale" },
- { GDK_VISUAL_STATIC_COLOR, "GDK_VISUAL_STATIC_COLOR", "static-color" },
- { GDK_VISUAL_PSEUDO_COLOR, "GDK_VISUAL_PSEUDO_COLOR", "pseudo-color" },
- { GDK_VISUAL_TRUE_COLOR, "GDK_VISUAL_TRUE_COLOR", "true-color" },
- { GDK_VISUAL_DIRECT_COLOR, "GDK_VISUAL_DIRECT_COLOR", "direct-color" },
-};
-static GtkEnumValue enum_values_GdkFontType[] = {
- { GDK_FONT_FONT, "GDK_FONT_FONT", "font" },
- { GDK_FONT_FONTSET, "GDK_FONT_FONTSET", "fontset" },
-};
-static GtkEnumValue enum_values_GdkWindowAttributesType[] = {
- { GDK_WA_TITLE, "GDK_WA_TITLE", "title" },
- { GDK_WA_X, "GDK_WA_X", "x" },
- { GDK_WA_Y, "GDK_WA_Y", "y" },
- { GDK_WA_CURSOR, "GDK_WA_CURSOR", "cursor" },
- { GDK_WA_COLORMAP, "GDK_WA_COLORMAP", "colormap" },
- { GDK_WA_VISUAL, "GDK_WA_VISUAL", "visual" },
- { GDK_WA_WMCLASS, "GDK_WA_WMCLASS", "wmclass" },
- { GDK_WA_NOREDIR, "GDK_WA_NOREDIR", "noredir" },
-};
-static GtkEnumValue enum_values_GdkWindowHints[] = {
- { GDK_HINT_POS, "GDK_HINT_POS", "pos" },
- { GDK_HINT_MIN_SIZE, "GDK_HINT_MIN_SIZE", "min-size" },
- { GDK_HINT_MAX_SIZE, "GDK_HINT_MAX_SIZE", "max-size" },
-};
-static GtkEnumValue enum_values_GdkFunction[] = {
- { GDK_COPY, "GDK_COPY", "copy" },
- { GDK_INVERT, "GDK_INVERT", "invert" },
- { GDK_XOR, "GDK_XOR", "xor" },
-};
-static GtkEnumValue enum_values_GdkFill[] = {
- { GDK_SOLID, "GDK_SOLID", "solid" },
- { GDK_TILED, "GDK_TILED", "tiled" },
- { GDK_STIPPLED, "GDK_STIPPLED", "stippled" },
- { GDK_OPAQUE_STIPPLED, "GDK_OPAQUE_STIPPLED", "opaque-stippled" },
-};
-static GtkEnumValue enum_values_GdkFillRule[] = {
- { GDK_EVEN_ODD_RULE, "GDK_EVEN_ODD_RULE", "even-odd-rule" },
- { GDK_WINDING_RULE, "GDK_WINDING_RULE", "winding-rule" },
-};
-static GtkEnumValue enum_values_GdkLineStyle[] = {
- { GDK_LINE_SOLID, "GDK_LINE_SOLID", "solid" },
- { GDK_LINE_ON_OFF_DASH, "GDK_LINE_ON_OFF_DASH", "on-off-dash" },
- { GDK_LINE_DOUBLE_DASH, "GDK_LINE_DOUBLE_DASH", "double-dash" },
-};
-static GtkEnumValue enum_values_GdkCapStyle[] = {
- { GDK_CAP_NOT_LAST, "GDK_CAP_NOT_LAST", "not-last" },
- { GDK_CAP_BUTT, "GDK_CAP_BUTT", "butt" },
- { GDK_CAP_ROUND, "GDK_CAP_ROUND", "round" },
- { GDK_CAP_PROJECTING, "GDK_CAP_PROJECTING", "projecting" },
-};
-static GtkEnumValue enum_values_GdkJoinStyle[] = {
- { GDK_JOIN_MITER, "GDK_JOIN_MITER", "miter" },
- { GDK_JOIN_ROUND, "GDK_JOIN_ROUND", "round" },
- { GDK_JOIN_BEVEL, "GDK_JOIN_BEVEL", "bevel" },
-};
-static GtkEnumValue enum_values_GdkFilterReturn[] = {
- { GDK_FILTER_CONTINUE, "GDK_FILTER_CONTINUE", "continue" },
- { GDK_FILTER_TRANSLATE, "GDK_FILTER_TRANSLATE", "translate" },
- { GDK_FILTER_REMOVE, "GDK_FILTER_REMOVE", "remove" },
-};
-static GtkEnumValue enum_values_GdkVisibilityState[] = {
- { GDK_VISIBILITY_UNOBSCURED, "GDK_VISIBILITY_UNOBSCURED", "unobscured" },
- { GDK_VISIBILITY_PARTIAL, "GDK_VISIBILITY_PARTIAL", "partial" },
- { GDK_VISIBILITY_FULLY_OBSCURED, "GDK_VISIBILITY_FULLY_OBSCURED", "fully-obscured" },
-};
-static GtkEnumValue enum_values_GdkEventType[] = {
- { GDK_NOTHING, "GDK_NOTHING", "nothing" },
- { GDK_DELETE, "GDK_DELETE", "delete" },
- { GDK_DESTROY, "GDK_DESTROY", "destroy" },
- { GDK_EXPOSE, "GDK_EXPOSE", "expose" },
- { GDK_MOTION_NOTIFY, "GDK_MOTION_NOTIFY", "motion-notify" },
- { GDK_BUTTON_PRESS, "GDK_BUTTON_PRESS", "button-press" },
- { GDK_2BUTTON_PRESS, "GDK_2BUTTON_PRESS", "2button-press" },
- { GDK_3BUTTON_PRESS, "GDK_3BUTTON_PRESS", "3button-press" },
- { GDK_BUTTON_RELEASE, "GDK_BUTTON_RELEASE", "button-release" },
- { GDK_KEY_PRESS, "GDK_KEY_PRESS", "key-press" },
- { GDK_KEY_RELEASE, "GDK_KEY_RELEASE", "key-release" },
- { GDK_ENTER_NOTIFY, "GDK_ENTER_NOTIFY", "enter-notify" },
- { GDK_LEAVE_NOTIFY, "GDK_LEAVE_NOTIFY", "leave-notify" },
- { GDK_FOCUS_CHANGE, "GDK_FOCUS_CHANGE", "focus-change" },
- { GDK_CONFIGURE, "GDK_CONFIGURE", "configure" },
- { GDK_MAP, "GDK_MAP", "map" },
- { GDK_UNMAP, "GDK_UNMAP", "unmap" },
- { GDK_PROPERTY_NOTIFY, "GDK_PROPERTY_NOTIFY", "property-notify" },
- { GDK_SELECTION_CLEAR, "GDK_SELECTION_CLEAR", "selection-clear" },
- { GDK_SELECTION_REQUEST, "GDK_SELECTION_REQUEST", "selection-request" },
- { GDK_SELECTION_NOTIFY, "GDK_SELECTION_NOTIFY", "selection-notify" },
- { GDK_PROXIMITY_IN, "GDK_PROXIMITY_IN", "proximity-in" },
- { GDK_PROXIMITY_OUT, "GDK_PROXIMITY_OUT", "proximity-out" },
- { GDK_DRAG_BEGIN, "GDK_DRAG_BEGIN", "drag-begin" },
- { GDK_DRAG_REQUEST, "GDK_DRAG_REQUEST", "drag-request" },
- { GDK_DROP_ENTER, "GDK_DROP_ENTER", "drop-enter" },
- { GDK_DROP_LEAVE, "GDK_DROP_LEAVE", "drop-leave" },
- { GDK_DROP_DATA_AVAIL, "GDK_DROP_DATA_AVAIL", "drop-data-avail" },
- { GDK_CLIENT_EVENT, "GDK_CLIENT_EVENT", "client-event" },
- { GDK_VISIBILITY_NOTIFY, "GDK_VISIBILITY_NOTIFY", "visibility-notify" },
- { GDK_NO_EXPOSE, "GDK_NO_EXPOSE", "no-expose" },
- { GDK_OTHER_EVENT, "GDK_OTHER_EVENT", "other-event" },
-};
-static GtkEnumValue enum_values_GdkEventMask[] = {
- { GDK_EXPOSURE_MASK, "GDK_EXPOSURE_MASK", "exposure-mask" },
- { GDK_POINTER_MOTION_MASK, "GDK_POINTER_MOTION_MASK", "pointer-motion-mask" },
- { GDK_POINTER_MOTION_HINT_MASK, "GDK_POINTER_MOTION_HINT_MASK", "pointer-motion-hint-mask" },
- { GDK_BUTTON_MOTION_MASK, "GDK_BUTTON_MOTION_MASK", "button-motion-mask" },
- { GDK_BUTTON1_MOTION_MASK, "GDK_BUTTON1_MOTION_MASK", "button1-motion-mask" },
- { GDK_BUTTON2_MOTION_MASK, "GDK_BUTTON2_MOTION_MASK", "button2-motion-mask" },
- { GDK_BUTTON3_MOTION_MASK, "GDK_BUTTON3_MOTION_MASK", "button3-motion-mask" },
- { GDK_BUTTON_PRESS_MASK, "GDK_BUTTON_PRESS_MASK", "button-press-mask" },
- { GDK_BUTTON_RELEASE_MASK, "GDK_BUTTON_RELEASE_MASK", "button-release-mask" },
- { GDK_KEY_PRESS_MASK, "GDK_KEY_PRESS_MASK", "key-press-mask" },
- { GDK_KEY_RELEASE_MASK, "GDK_KEY_RELEASE_MASK", "key-release-mask" },
- { GDK_ENTER_NOTIFY_MASK, "GDK_ENTER_NOTIFY_MASK", "enter-notify-mask" },
- { GDK_LEAVE_NOTIFY_MASK, "GDK_LEAVE_NOTIFY_MASK", "leave-notify-mask" },
- { GDK_FOCUS_CHANGE_MASK, "GDK_FOCUS_CHANGE_MASK", "focus-change-mask" },
- { GDK_STRUCTURE_MASK, "GDK_STRUCTURE_MASK", "structure-mask" },
- { GDK_PROPERTY_CHANGE_MASK, "GDK_PROPERTY_CHANGE_MASK", "property-change-mask" },
- { GDK_VISIBILITY_NOTIFY_MASK, "GDK_VISIBILITY_NOTIFY_MASK", "visibility-notify-mask" },
- { GDK_PROXIMITY_IN_MASK, "GDK_PROXIMITY_IN_MASK", "proximity-in-mask" },
- { GDK_PROXIMITY_OUT_MASK, "GDK_PROXIMITY_OUT_MASK", "proximity-out-mask" },
- { GDK_SUBSTRUCTURE_MASK, "GDK_SUBSTRUCTURE_MASK", "substructure-mask" },
- { GDK_ALL_EVENTS_MASK, "GDK_ALL_EVENTS_MASK", "all-events-mask" },
-};
-static GtkEnumValue enum_values_GdkNotifyType[] = {
- { GDK_NOTIFY_ANCESTOR, "GDK_NOTIFY_ANCESTOR", "ancestor" },
- { GDK_NOTIFY_VIRTUAL, "GDK_NOTIFY_VIRTUAL", "virtual" },
- { GDK_NOTIFY_INFERIOR, "GDK_NOTIFY_INFERIOR", "inferior" },
- { GDK_NOTIFY_NONLINEAR, "GDK_NOTIFY_NONLINEAR", "nonlinear" },
- { GDK_NOTIFY_NONLINEAR_VIRTUAL, "GDK_NOTIFY_NONLINEAR_VIRTUAL", "nonlinear-virtual" },
- { GDK_NOTIFY_UNKNOWN, "GDK_NOTIFY_UNKNOWN", "unknown" },
-};
-static GtkEnumValue enum_values_GdkCrossingMode[] = {
- { GDK_CROSSING_NORMAL, "GDK_CROSSING_NORMAL", "crossing-normal" },
- { GDK_CROSSING_GRAB, "GDK_CROSSING_GRAB", "crossing-grab" },
- { GDK_CROSSING_UNGRAB, "GDK_CROSSING_UNGRAB", "crossing-ungrab" },
-};
-static GtkEnumValue enum_values_GdkModifierType[] = {
- { GDK_SHIFT_MASK, "GDK_SHIFT_MASK", "shift-mask" },
- { GDK_LOCK_MASK, "GDK_LOCK_MASK", "lock-mask" },
- { GDK_CONTROL_MASK, "GDK_CONTROL_MASK", "control-mask" },
- { GDK_MOD1_MASK, "GDK_MOD1_MASK", "mod1-mask" },
- { GDK_MOD2_MASK, "GDK_MOD2_MASK", "mod2-mask" },
- { GDK_MOD3_MASK, "GDK_MOD3_MASK", "mod3-mask" },
- { GDK_MOD4_MASK, "GDK_MOD4_MASK", "mod4-mask" },
- { GDK_MOD5_MASK, "GDK_MOD5_MASK", "mod5-mask" },
- { GDK_BUTTON1_MASK, "GDK_BUTTON1_MASK", "button1-mask" },
- { GDK_BUTTON2_MASK, "GDK_BUTTON2_MASK", "button2-mask" },
- { GDK_BUTTON3_MASK, "GDK_BUTTON3_MASK", "button3-mask" },
- { GDK_BUTTON4_MASK, "GDK_BUTTON4_MASK", "button4-mask" },
- { GDK_BUTTON5_MASK, "GDK_BUTTON5_MASK", "button5-mask" },
- { GDK_AFTER_MASK, "GDK_AFTER_MASK", "after-mask" },
- { GDK_MODIFIER_MASK, "GDK_MODIFIER_MASK", "modifier-mask" },
-};
-static GtkEnumValue enum_values_GdkSubwindowMode[] = {
- { GDK_CLIP_BY_CHILDREN, "GDK_CLIP_BY_CHILDREN", "clip-by-children" },
- { GDK_INCLUDE_INFERIORS, "GDK_INCLUDE_INFERIORS", "include-inferiors" },
-};
-static GtkEnumValue enum_values_GdkInputCondition[] = {
- { GDK_INPUT_READ, "GDK_INPUT_READ", "read" },
- { GDK_INPUT_WRITE, "GDK_INPUT_WRITE", "write" },
- { GDK_INPUT_EXCEPTION, "GDK_INPUT_EXCEPTION", "exception" },
-};
-static GtkEnumValue enum_values_GdkStatus[] = {
- { GDK_OK, "GDK_OK", "ok" },
- { GDK_ERROR, "GDK_ERROR", "error" },
- { GDK_ERROR_PARAM, "GDK_ERROR_PARAM", "error-param" },
- { GDK_ERROR_FILE, "GDK_ERROR_FILE", "error-file" },
- { GDK_ERROR_MEM, "GDK_ERROR_MEM", "error-mem" },
-};
-static GtkEnumValue enum_values_GdkByteOrder[] = {
- { GDK_LSB_FIRST, "GDK_LSB_FIRST", "lsb-first" },
- { GDK_MSB_FIRST, "GDK_MSB_FIRST", "msb-first" },
-};
-static GtkEnumValue enum_values_GdkGCValuesMask[] = {
- { GDK_GC_FOREGROUND, "GDK_GC_FOREGROUND", "foreground" },
- { GDK_GC_BACKGROUND, "GDK_GC_BACKGROUND", "background" },
- { GDK_GC_FONT, "GDK_GC_FONT", "font" },
- { GDK_GC_FUNCTION, "GDK_GC_FUNCTION", "function" },
- { GDK_GC_FILL, "GDK_GC_FILL", "fill" },
- { GDK_GC_TILE, "GDK_GC_TILE", "tile" },
- { GDK_GC_STIPPLE, "GDK_GC_STIPPLE", "stipple" },
- { GDK_GC_CLIP_MASK, "GDK_GC_CLIP_MASK", "clip-mask" },
- { GDK_GC_SUBWINDOW, "GDK_GC_SUBWINDOW", "subwindow" },
- { GDK_GC_TS_X_ORIGIN, "GDK_GC_TS_X_ORIGIN", "ts-x-origin" },
- { GDK_GC_TS_Y_ORIGIN, "GDK_GC_TS_Y_ORIGIN", "ts-y-origin" },
- { GDK_GC_CLIP_X_ORIGIN, "GDK_GC_CLIP_X_ORIGIN", "clip-x-origin" },
- { GDK_GC_CLIP_Y_ORIGIN, "GDK_GC_CLIP_Y_ORIGIN", "clip-y-origin" },
- { GDK_GC_EXPOSURES, "GDK_GC_EXPOSURES", "exposures" },
- { GDK_GC_LINE_WIDTH, "GDK_GC_LINE_WIDTH", "line-width" },
- { GDK_GC_LINE_STYLE, "GDK_GC_LINE_STYLE", "line-style" },
- { GDK_GC_CAP_STYLE, "GDK_GC_CAP_STYLE", "cap-style" },
- { GDK_GC_JOIN_STYLE, "GDK_GC_JOIN_STYLE", "join-style" },
-};
-static GtkEnumValue enum_values_GdkSelection[] = {
- { GDK_SELECTION_PRIMARY, "GDK_SELECTION_PRIMARY", "primary" },
- { GDK_SELECTION_SECONDARY, "GDK_SELECTION_SECONDARY", "secondary" },
-};
-static GtkEnumValue enum_values_GdkPropertyState[] = {
- { GDK_PROPERTY_NEW_VALUE, "GDK_PROPERTY_NEW_VALUE", "new-value" },
- { GDK_PROPERTY_DELETE, "GDK_PROPERTY_DELETE", "delete" },
-};
-static GtkEnumValue enum_values_GdkPropMode[] = {
- { GDK_PROP_MODE_REPLACE, "GDK_PROP_MODE_REPLACE", "replace" },
- { GDK_PROP_MODE_PREPEND, "GDK_PROP_MODE_PREPEND", "prepend" },
- { GDK_PROP_MODE_APPEND, "GDK_PROP_MODE_APPEND", "append" },
-};
-static GtkEnumValue enum_values_GdkDndType[] = {
- { GDK_DNDTYPE_NOTDND, "GDK_DNDTYPE_NOTDND", "notdnd" },
- { GDK_DNDTYPE_UNKNOWN, "GDK_DNDTYPE_UNKNOWN", "unknown" },
- { GDK_DNDTYPE_RAWDATA, "GDK_DNDTYPE_RAWDATA", "rawdata" },
- { GDK_DNDTYPE_FILE, "GDK_DNDTYPE_FILE", "file" },
- { GDK_DNDTYPE_FILES, "GDK_DNDTYPE_FILES", "files" },
- { GDK_DNDTYPE_TEXT, "GDK_DNDTYPE_TEXT", "text" },
- { GDK_DNDTYPE_DIR, "GDK_DNDTYPE_DIR", "dir" },
- { GDK_DNDTYPE_LINK, "GDK_DNDTYPE_LINK", "link" },
- { GDK_DNDTYPE_EXE, "GDK_DNDTYPE_EXE", "exe" },
- { GDK_DNDTYPE_URL, "GDK_DNDTYPE_URL", "url" },
- { GDK_DNDTYPE_MIME, "GDK_DNDTYPE_MIME", "mime" },
- { GDK_DNDTYPE_END, "GDK_DNDTYPE_END", "end" },
-};
-static GtkEnumValue enum_values_GdkInputSource[] = {
- { GDK_SOURCE_MOUSE, "GDK_SOURCE_MOUSE", "mouse" },
- { GDK_SOURCE_PEN, "GDK_SOURCE_PEN", "pen" },
- { GDK_SOURCE_ERASER, "GDK_SOURCE_ERASER", "eraser" },
- { GDK_SOURCE_CURSOR, "GDK_SOURCE_CURSOR", "cursor" },
-};
-static GtkEnumValue enum_values_GdkInputMode[] = {
- { GDK_MODE_DISABLED, "GDK_MODE_DISABLED", "disabled" },
- { GDK_MODE_SCREEN, "GDK_MODE_SCREEN", "screen" },
- { GDK_MODE_WINDOW, "GDK_MODE_WINDOW", "window" },
-};
-static GtkEnumValue enum_values_GdkAxisUse[] = {
- { GDK_AXIS_IGNORE, "GDK_AXIS_IGNORE", "ignore" },
- { GDK_AXIS_X, "GDK_AXIS_X", "x" },
- { GDK_AXIS_Y, "GDK_AXIS_Y", "y" },
- { GDK_AXIS_PRESSURE, "GDK_AXIS_PRESSURE", "pressure" },
- { GDK_AXIS_XTILT, "GDK_AXIS_XTILT", "xtilt" },
- { GDK_AXIS_YTILT, "GDK_AXIS_YTILT", "ytilt" },
- { GDK_AXIS_LAST, "GDK_AXIS_LAST", "last" },
-};
-static GtkEnumValue enum_values_GdkTarget[] = {
- { GDK_TARGET_BITMAP, "GDK_TARGET_BITMAP", "bitmap" },
- { GDK_TARGET_COLORMAP, "GDK_TARGET_COLORMAP", "colormap" },
- { GDK_TARGET_DRAWABLE, "GDK_TARGET_DRAWABLE", "drawable" },
- { GDK_TARGET_PIXMAP, "GDK_TARGET_PIXMAP", "pixmap" },
- { GDK_TARGET_STRING, "GDK_TARGET_STRING", "string" },
-};
-static GtkEnumValue enum_values_GdkSelectionType[] = {
- { GDK_SELECTION_TYPE_ATOM, "GDK_SELECTION_TYPE_ATOM", "atom" },
- { GDK_SELECTION_TYPE_BITMAP, "GDK_SELECTION_TYPE_BITMAP", "bitmap" },
- { GDK_SELECTION_TYPE_COLORMAP, "GDK_SELECTION_TYPE_COLORMAP", "colormap" },
- { GDK_SELECTION_TYPE_DRAWABLE, "GDK_SELECTION_TYPE_DRAWABLE", "drawable" },
- { GDK_SELECTION_TYPE_INTEGER, "GDK_SELECTION_TYPE_INTEGER", "integer" },
- { GDK_SELECTION_TYPE_PIXMAP, "GDK_SELECTION_TYPE_PIXMAP", "pixmap" },
- { GDK_SELECTION_TYPE_WINDOW, "GDK_SELECTION_TYPE_WINDOW", "window" },
- { GDK_SELECTION_TYPE_STRING, "GDK_SELECTION_TYPE_STRING", "string" },
-};
-static GtkEnumValue enum_values_GdkExtensionMode[] = {
- { GDK_EXTENSION_EVENTS_NONE, "GDK_EXTENSION_EVENTS_NONE", "none" },
- { GDK_EXTENSION_EVENTS_ALL, "GDK_EXTENSION_EVENTS_ALL", "all" },
- { GDK_EXTENSION_EVENTS_CURSOR, "GDK_EXTENSION_EVENTS_CURSOR", "cursor" },
-};
-static GtkEnumValue enum_values_GdkWMDecoration[] = {
- { GDK_DECOR_ALL, "GDK_DECOR_ALL", "all" },
- { GDK_DECOR_BORDER, "GDK_DECOR_BORDER", "border" },
- { GDK_DECOR_RESIZEH, "GDK_DECOR_RESIZEH", "resizeh" },
- { GDK_DECOR_TITLE, "GDK_DECOR_TITLE", "title" },
- { GDK_DECOR_MENU, "GDK_DECOR_MENU", "menu" },
- { GDK_DECOR_MINIMIZE, "GDK_DECOR_MINIMIZE", "minimize" },
- { GDK_DECOR_MAXIMIZE, "GDK_DECOR_MAXIMIZE", "maximize" },
-};
-static GtkEnumValue enum_values_GdkWMFunction[] = {
- { GDK_FUNC_ALL, "GDK_FUNC_ALL", "all" },
- { GDK_FUNC_RESIZE, "GDK_FUNC_RESIZE", "resize" },
- { GDK_FUNC_MOVE, "GDK_FUNC_MOVE", "move" },
- { GDK_FUNC_MINIMIZE, "GDK_FUNC_MINIMIZE", "minimize" },
- { GDK_FUNC_MAXIMIZE, "GDK_FUNC_MAXIMIZE", "maximize" },
- { GDK_FUNC_CLOSE, "GDK_FUNC_CLOSE", "close" },
-};
-static GtkEnumValue enum_values_GdkColorContextMode[] = {
- { GDK_CC_MODE_UNDEFINED, "GDK_CC_MODE_UNDEFINED", "undefined" },
- { GDK_CC_MODE_BW, "GDK_CC_MODE_BW", "bw" },
- { GDK_CC_MODE_STD_CMAP, "GDK_CC_MODE_STD_CMAP", "std-cmap" },
- { GDK_CC_MODE_TRUE, "GDK_CC_MODE_TRUE", "true" },
- { GDK_CC_MODE_MY_GRAY, "GDK_CC_MODE_MY_GRAY", "my-gray" },
- { GDK_CC_MODE_PALETTE, "GDK_CC_MODE_PALETTE", "palette" },
-};
-static GtkEnumValue enum_values_GdkOverlapType[] = {
- { GDK_OVERLAP_RECTANGLE_IN, "GDK_OVERLAP_RECTANGLE_IN", "in" },
- { GDK_OVERLAP_RECTANGLE_OUT, "GDK_OVERLAP_RECTANGLE_OUT", "out" },
- { GDK_OVERLAP_RECTANGLE_PART, "GDK_OVERLAP_RECTANGLE_PART", "part" },
-};
-static GtkEnumValue enum_values_GtkAccelFlags[] = {
- { GTK_ACCEL_VISIBLE, "GTK_ACCEL_VISIBLE", "visible" },
- { GTK_ACCEL_SIGNAL_VISIBLE, "GTK_ACCEL_SIGNAL_VISIBLE", "signal-visible" },
- { GTK_ACCEL_LOCKED, "GTK_ACCEL_LOCKED", "locked" },
- { GTK_ACCEL_MASK, "GTK_ACCEL_MASK", "mask" },
-};
-static GtkEnumValue enum_values_GtkArrowType[] = {
- { GTK_ARROW_UP, "GTK_ARROW_UP", "up" },
- { GTK_ARROW_DOWN, "GTK_ARROW_DOWN", "down" },
- { GTK_ARROW_LEFT, "GTK_ARROW_LEFT", "left" },
- { GTK_ARROW_RIGHT, "GTK_ARROW_RIGHT", "right" },
-};
-static GtkEnumValue enum_values_GtkAttachOptions[] = {
- { GTK_EXPAND, "GTK_EXPAND", "expand" },
- { GTK_SHRINK, "GTK_SHRINK", "shrink" },
- { GTK_FILL, "GTK_FILL", "fill" },
-};
-static GtkEnumValue enum_values_GtkButtonBoxStyle[] = {
- { GTK_BUTTONBOX_DEFAULT_STYLE, "GTK_BUTTONBOX_DEFAULT_STYLE", "default" },
- { GTK_BUTTONBOX_SPREAD, "GTK_BUTTONBOX_SPREAD", "spread" },
- { GTK_BUTTONBOX_EDGE, "GTK_BUTTONBOX_EDGE", "edge" },
- { GTK_BUTTONBOX_START, "GTK_BUTTONBOX_START", "start" },
- { GTK_BUTTONBOX_END, "GTK_BUTTONBOX_END", "end" },
-};
-static GtkEnumValue enum_values_GtkCurveType[] = {
- { GTK_CURVE_TYPE_LINEAR, "GTK_CURVE_TYPE_LINEAR", "linear" },
- { GTK_CURVE_TYPE_SPLINE, "GTK_CURVE_TYPE_SPLINE", "spline" },
- { GTK_CURVE_TYPE_FREE, "GTK_CURVE_TYPE_FREE", "free" },
-};
-static GtkEnumValue enum_values_GtkDirectionType[] = {
- { GTK_DIR_TAB_FORWARD, "GTK_DIR_TAB_FORWARD", "tab-forward" },
- { GTK_DIR_TAB_BACKWARD, "GTK_DIR_TAB_BACKWARD", "tab-backward" },
- { GTK_DIR_UP, "GTK_DIR_UP", "up" },
- { GTK_DIR_DOWN, "GTK_DIR_DOWN", "down" },
- { GTK_DIR_LEFT, "GTK_DIR_LEFT", "left" },
- { GTK_DIR_RIGHT, "GTK_DIR_RIGHT", "right" },
-};
-static GtkEnumValue enum_values_GtkJustification[] = {
- { GTK_JUSTIFY_LEFT, "GTK_JUSTIFY_LEFT", "left" },
- { GTK_JUSTIFY_RIGHT, "GTK_JUSTIFY_RIGHT", "right" },
- { GTK_JUSTIFY_CENTER, "GTK_JUSTIFY_CENTER", "center" },
- { GTK_JUSTIFY_FILL, "GTK_JUSTIFY_FILL", "fill" },
-};
-static GtkEnumValue enum_values_GtkMatchType[] = {
- { GTK_MATCH_ALL, "GTK_MATCH_ALL", "all" },
- { GTK_MATCH_ALL_TAIL, "GTK_MATCH_ALL_TAIL", "all-tail" },
- { GTK_MATCH_HEAD, "GTK_MATCH_HEAD", "head" },
- { GTK_MATCH_TAIL, "GTK_MATCH_TAIL", "tail" },
- { GTK_MATCH_EXACT, "GTK_MATCH_EXACT", "exact" },
- { GTK_MATCH_LAST, "GTK_MATCH_LAST", "last" },
-};
-static GtkEnumValue enum_values_GtkMenuFactoryType[] = {
- { GTK_MENU_FACTORY_MENU, "GTK_MENU_FACTORY_MENU", "menu" },
- { GTK_MENU_FACTORY_MENU_BAR, "GTK_MENU_FACTORY_MENU_BAR", "menu-bar" },
- { GTK_MENU_FACTORY_OPTION_MENU, "GTK_MENU_FACTORY_OPTION_MENU", "option-menu" },
-};
-static GtkEnumValue enum_values_GtkMetricType[] = {
- { GTK_PIXELS, "GTK_PIXELS", "pixels" },
- { GTK_INCHES, "GTK_INCHES", "inches" },
- { GTK_CENTIMETERS, "GTK_CENTIMETERS", "centimeters" },
-};
-static GtkEnumValue enum_values_GtkOrientation[] = {
- { GTK_ORIENTATION_HORIZONTAL, "GTK_ORIENTATION_HORIZONTAL", "horizontal" },
- { GTK_ORIENTATION_VERTICAL, "GTK_ORIENTATION_VERTICAL", "vertical" },
-};
-static GtkEnumValue enum_values_GtkPackType[] = {
- { GTK_PACK_START, "GTK_PACK_START", "start" },
- { GTK_PACK_END, "GTK_PACK_END", "end" },
-};
-static GtkEnumValue enum_values_GtkPathPriorityType[] = {
- { GTK_PATH_PRIO_LOWEST, "GTK_PATH_PRIO_LOWEST", "lowest" },
- { GTK_PATH_PRIO_GTK, "GTK_PATH_PRIO_GTK", "gtk" },
- { GTK_PATH_PRIO_APPLICATION, "GTK_PATH_PRIO_APPLICATION", "application" },
- { GTK_PATH_PRIO_RC, "GTK_PATH_PRIO_RC", "rc" },
- { GTK_PATH_PRIO_HIGHEST, "GTK_PATH_PRIO_HIGHEST", "highest" },
- { GTK_PATH_PRIO_MASK, "GTK_PATH_PRIO_MASK", "mask" },
-};
-static GtkEnumValue enum_values_GtkPathType[] = {
- { GTK_PATH_WIDGET, "GTK_PATH_WIDGET", "widget" },
- { GTK_PATH_WIDGET_CLASS, "GTK_PATH_WIDGET_CLASS", "widget-class" },
- { GTK_PATH_CLASS, "GTK_PATH_CLASS", "class" },
-};
-static GtkEnumValue enum_values_GtkPolicyType[] = {
- { GTK_POLICY_ALWAYS, "GTK_POLICY_ALWAYS", "always" },
- { GTK_POLICY_AUTOMATIC, "GTK_POLICY_AUTOMATIC", "automatic" },
-};
-static GtkEnumValue enum_values_GtkPositionType[] = {
- { GTK_POS_LEFT, "GTK_POS_LEFT", "left" },
- { GTK_POS_RIGHT, "GTK_POS_RIGHT", "right" },
- { GTK_POS_TOP, "GTK_POS_TOP", "top" },
- { GTK_POS_BOTTOM, "GTK_POS_BOTTOM", "bottom" },
-};
-static GtkEnumValue enum_values_GtkPreviewType[] = {
- { GTK_PREVIEW_COLOR, "GTK_PREVIEW_COLOR", "color" },
- { GTK_PREVIEW_GRAYSCALE, "GTK_PREVIEW_GRAYSCALE", "grayscale" },
- { GTK_PREVIEW_GREYSCALE, "GTK_PREVIEW_GREYSCALE", "greyscale" },
-};
-static GtkEnumValue enum_values_GtkReliefStyle[] = {
- { GTK_RELIEF_NORMAL, "GTK_RELIEF_NORMAL", "normal" },
- { GTK_RELIEF_NONE, "GTK_RELIEF_NONE", "none" },
-};
-static GtkEnumValue enum_values_GtkScrollType[] = {
- { GTK_SCROLL_NONE, "GTK_SCROLL_NONE", "none" },
- { GTK_SCROLL_STEP_BACKWARD, "GTK_SCROLL_STEP_BACKWARD", "step-backward" },
- { GTK_SCROLL_STEP_FORWARD, "GTK_SCROLL_STEP_FORWARD", "step-forward" },
- { GTK_SCROLL_PAGE_BACKWARD, "GTK_SCROLL_PAGE_BACKWARD", "page-backward" },
- { GTK_SCROLL_PAGE_FORWARD, "GTK_SCROLL_PAGE_FORWARD", "page-forward" },
- { GTK_SCROLL_JUMP, "GTK_SCROLL_JUMP", "jump" },
-};
-static GtkEnumValue enum_values_GtkSelectionMode[] = {
- { GTK_SELECTION_SINGLE, "GTK_SELECTION_SINGLE", "single" },
- { GTK_SELECTION_BROWSE, "GTK_SELECTION_BROWSE", "browse" },
- { GTK_SELECTION_MULTIPLE, "GTK_SELECTION_MULTIPLE", "multiple" },
- { GTK_SELECTION_EXTENDED, "GTK_SELECTION_EXTENDED", "extended" },
-};
-static GtkEnumValue enum_values_GtkShadowType[] = {
- { GTK_SHADOW_NONE, "GTK_SHADOW_NONE", "none" },
- { GTK_SHADOW_IN, "GTK_SHADOW_IN", "in" },
- { GTK_SHADOW_OUT, "GTK_SHADOW_OUT", "out" },
- { GTK_SHADOW_ETCHED_IN, "GTK_SHADOW_ETCHED_IN", "etched-in" },
- { GTK_SHADOW_ETCHED_OUT, "GTK_SHADOW_ETCHED_OUT", "etched-out" },
-};
-static GtkEnumValue enum_values_GtkSignalRunType[] = {
- { GTK_RUN_FIRST, "GTK_RUN_FIRST", "first" },
- { GTK_RUN_LAST, "GTK_RUN_LAST", "last" },
- { GTK_RUN_BOTH, "GTK_RUN_BOTH", "both" },
- { GTK_RUN_MASK, "GTK_RUN_MASK", "mask" },
- { GTK_RUN_NO_RECURSE, "GTK_RUN_NO_RECURSE", "no-recurse" },
-};
-static GtkEnumValue enum_values_GtkStateType[] = {
- { GTK_STATE_NORMAL, "GTK_STATE_NORMAL", "normal" },
- { GTK_STATE_ACTIVE, "GTK_STATE_ACTIVE", "active" },
- { GTK_STATE_PRELIGHT, "GTK_STATE_PRELIGHT", "prelight" },
- { GTK_STATE_SELECTED, "GTK_STATE_SELECTED", "selected" },
- { GTK_STATE_INSENSITIVE, "GTK_STATE_INSENSITIVE", "insensitive" },
-};
-static GtkEnumValue enum_values_GtkSubmenuDirection[] = {
- { GTK_DIRECTION_LEFT, "GTK_DIRECTION_LEFT", "left" },
- { GTK_DIRECTION_RIGHT, "GTK_DIRECTION_RIGHT", "right" },
-};
-static GtkEnumValue enum_values_GtkSubmenuPlacement[] = {
- { GTK_TOP_BOTTOM, "GTK_TOP_BOTTOM", "top-bottom" },
- { GTK_LEFT_RIGHT, "GTK_LEFT_RIGHT", "left-right" },
-};
-static GtkEnumValue enum_values_GtkToolbarStyle[] = {
- { GTK_TOOLBAR_ICONS, "GTK_TOOLBAR_ICONS", "icons" },
- { GTK_TOOLBAR_TEXT, "GTK_TOOLBAR_TEXT", "text" },
- { GTK_TOOLBAR_BOTH, "GTK_TOOLBAR_BOTH", "both" },
-};
-static GtkEnumValue enum_values_GtkTroughType[] = {
- { GTK_TROUGH_NONE, "GTK_TROUGH_NONE", "none" },
- { GTK_TROUGH_START, "GTK_TROUGH_START", "start" },
- { GTK_TROUGH_END, "GTK_TROUGH_END", "end" },
- { GTK_TROUGH_JUMP, "GTK_TROUGH_JUMP", "jump" },
-};
-static GtkEnumValue enum_values_GtkUpdateType[] = {
- { GTK_UPDATE_CONTINUOUS, "GTK_UPDATE_CONTINUOUS", "continuous" },
- { GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" },
- { GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" },
-};
-static GtkEnumValue enum_values_GtkVisibility[] = {
- { GTK_VISIBILITY_NONE, "GTK_VISIBILITY_NONE", "none" },
- { GTK_VISIBILITY_PARTIAL, "GTK_VISIBILITY_PARTIAL", "partial" },
- { GTK_VISIBILITY_FULL, "GTK_VISIBILITY_FULL", "full" },
-};
-static GtkEnumValue enum_values_GtkWindowPosition[] = {
- { GTK_WIN_POS_NONE, "GTK_WIN_POS_NONE", "none" },
- { GTK_WIN_POS_CENTER, "GTK_WIN_POS_CENTER", "center" },
- { GTK_WIN_POS_MOUSE, "GTK_WIN_POS_MOUSE", "mouse" },
-};
-static GtkEnumValue enum_values_GtkWindowType[] = {
- { GTK_WINDOW_TOPLEVEL, "GTK_WINDOW_TOPLEVEL", "toplevel" },
- { GTK_WINDOW_DIALOG, "GTK_WINDOW_DIALOG", "dialog" },
- { GTK_WINDOW_POPUP, "GTK_WINDOW_POPUP", "popup" },
-};
-static GtkEnumValue enum_values_GtkFundamentalType[] = {
- { GTK_TYPE_INVALID, "GTK_TYPE_INVALID", "invalid" },
- { GTK_TYPE_NONE, "GTK_TYPE_NONE", "none" },
- { GTK_TYPE_CHAR, "GTK_TYPE_CHAR", "char" },
- { GTK_TYPE_BOOL, "GTK_TYPE_BOOL", "bool" },
- { GTK_TYPE_INT, "GTK_TYPE_INT", "int" },
- { GTK_TYPE_UINT, "GTK_TYPE_UINT", "uint" },
- { GTK_TYPE_LONG, "GTK_TYPE_LONG", "long" },
- { GTK_TYPE_ULONG, "GTK_TYPE_ULONG", "ulong" },
- { GTK_TYPE_FLOAT, "GTK_TYPE_FLOAT", "float" },
- { GTK_TYPE_DOUBLE, "GTK_TYPE_DOUBLE", "double" },
- { GTK_TYPE_STRING, "GTK_TYPE_STRING", "string" },
- { GTK_TYPE_ENUM, "GTK_TYPE_ENUM", "enum" },
- { GTK_TYPE_FLAGS, "GTK_TYPE_FLAGS", "flags" },
- { GTK_TYPE_BOXED, "GTK_TYPE_BOXED", "boxed" },
- { GTK_TYPE_FOREIGN, "GTK_TYPE_FOREIGN", "foreign" },
- { GTK_TYPE_CALLBACK, "GTK_TYPE_CALLBACK", "callback" },
- { GTK_TYPE_ARGS, "GTK_TYPE_ARGS", "args" },
- { GTK_TYPE_POINTER, "GTK_TYPE_POINTER", "pointer" },
- { GTK_TYPE_SIGNAL, "GTK_TYPE_SIGNAL", "signal" },
- { GTK_TYPE_C_CALLBACK, "GTK_TYPE_C_CALLBACK", "c-callback" },
- { GTK_TYPE_OBJECT, "GTK_TYPE_OBJECT", "object" },
-};
-static GtkEnumValue enum_values_GtkDebugFlag[] = {
- { GTK_DEBUG_OBJECTS, "GTK_DEBUG_OBJECTS", "objects" },
- { GTK_DEBUG_MISC, "GTK_DEBUG_MISC", "misc" },
- { GTK_DEBUG_SIGNALS, "GTK_DEBUG_SIGNALS", "signals" },
-};
-static GtkEnumValue enum_values_GtkObjectFlags[] = {
- { GTK_DESTROYED, "GTK_DESTROYED", "destroyed" },
- { GTK_FLOATING, "GTK_FLOATING", "floating" },
- { GTK_CONNECTED, "GTK_CONNECTED", "connected" },
- { GTK_OBJECT_FLAG_LAST, "GTK_OBJECT_FLAG_LAST", "object-flag-last" },
-};
-static GtkEnumValue enum_values_GtkArgFlags[] = {
- { GTK_ARG_READABLE, "GTK_ARG_READABLE", "readable" },
- { GTK_ARG_WRITABLE, "GTK_ARG_WRITABLE", "writable" },
- { GTK_ARG_CONSTRUCT, "GTK_ARG_CONSTRUCT", "construct" },
- { GTK_ARG_MASK, "GTK_ARG_MASK", "mask" },
- { GTK_ARG_READWRITE, "GTK_ARG_READWRITE", "readwrite" },
-};
-static GtkEnumValue enum_values_GtkWidgetFlags[] = {
- { GTK_TOPLEVEL, "GTK_TOPLEVEL", "toplevel" },
- { GTK_NO_WINDOW, "GTK_NO_WINDOW", "no-window" },
- { GTK_REALIZED, "GTK_REALIZED", "realized" },
- { GTK_MAPPED, "GTK_MAPPED", "mapped" },
- { GTK_VISIBLE, "GTK_VISIBLE", "visible" },
- { GTK_SENSITIVE, "GTK_SENSITIVE", "sensitive" },
- { GTK_PARENT_SENSITIVE, "GTK_PARENT_SENSITIVE", "parent-sensitive" },
- { GTK_CAN_FOCUS, "GTK_CAN_FOCUS", "can-focus" },
- { GTK_HAS_FOCUS, "GTK_HAS_FOCUS", "has-focus" },
- { GTK_CAN_DEFAULT, "GTK_CAN_DEFAULT", "can-default" },
- { GTK_HAS_DEFAULT, "GTK_HAS_DEFAULT", "has-default" },
- { GTK_HAS_GRAB, "GTK_HAS_GRAB", "has-grab" },
- { GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" },
- { GTK_BASIC, "GTK_BASIC", "basic" },
-};
-static GtkEnumValue enum_values_GtkPrivateFlags[] = {
- { PRIVATE_GTK_USER_STYLE, "PRIVATE_GTK_USER_STYLE", "user-style" },
- { PRIVATE_GTK_REDRAW_PENDING, "PRIVATE_GTK_REDRAW_PENDING", "redraw-pending" },
- { PRIVATE_GTK_RESIZE_PENDING, "PRIVATE_GTK_RESIZE_PENDING", "resize-pending" },
- { PRIVATE_GTK_RESIZE_NEEDED, "PRIVATE_GTK_RESIZE_NEEDED", "resize-needed" },
- { PRIVATE_GTK_LEAVE_PENDING, "PRIVATE_GTK_LEAVE_PENDING", "leave-pending" },
- { PRIVATE_GTK_HAS_SHAPE_MASK, "PRIVATE_GTK_HAS_SHAPE_MASK", "has-shape-mask" },
- { PRIVATE_GTK_IN_REPARENT, "PRIVATE_GTK_IN_REPARENT", "in-reparent" },
-};
-static GtkEnumValue enum_values_GdkDebugFlag[] = {
- { GDK_DEBUG_MISC, "GDK_DEBUG_MISC", "misc" },
- { GDK_DEBUG_EVENTS, "GDK_DEBUG_EVENTS", "events" },
- { GDK_DEBUG_DND, "GDK_DEBUG_DND", "dnd" },
- { GDK_DEBUG_COLOR_CONTEXT, "GDK_DEBUG_COLOR_CONTEXT", "color-context" },
- { GDK_DEBUG_XIM, "GDK_DEBUG_XIM", "xim" },
-};
-
+++ /dev/null
-/* generated by gentypeinfo from "gtk.defs" */
-
- { "GdkWindowType", GTK_TYPE_ENUM, enum_values_GdkWindowType },
- { "GdkWindowClass", GTK_TYPE_ENUM, enum_values_GdkWindowClass },
- { "GdkImageType", GTK_TYPE_ENUM, enum_values_GdkImageType },
- { "GdkVisualType", GTK_TYPE_ENUM, enum_values_GdkVisualType },
- { "GdkFontType", GTK_TYPE_ENUM, enum_values_GdkFontType },
- { "GdkWindowAttributesType", GTK_TYPE_FLAGS, enum_values_GdkWindowAttributesType },
- { "GdkWindowHints", GTK_TYPE_FLAGS, enum_values_GdkWindowHints },
- { "GdkFunction", GTK_TYPE_ENUM, enum_values_GdkFunction },
- { "GdkFill", GTK_TYPE_ENUM, enum_values_GdkFill },
- { "GdkFillRule", GTK_TYPE_ENUM, enum_values_GdkFillRule },
- { "GdkLineStyle", GTK_TYPE_ENUM, enum_values_GdkLineStyle },
- { "GdkCapStyle", GTK_TYPE_ENUM, enum_values_GdkCapStyle },
- { "GdkJoinStyle", GTK_TYPE_ENUM, enum_values_GdkJoinStyle },
- { "GdkFilterReturn", GTK_TYPE_ENUM, enum_values_GdkFilterReturn },
- { "GdkVisibilityState", GTK_TYPE_ENUM, enum_values_GdkVisibilityState },
- { "GdkEventType", GTK_TYPE_ENUM, enum_values_GdkEventType },
- { "GdkEventMask", GTK_TYPE_FLAGS, enum_values_GdkEventMask },
- { "GdkNotifyType", GTK_TYPE_ENUM, enum_values_GdkNotifyType },
- { "GdkCrossingMode", GTK_TYPE_ENUM, enum_values_GdkCrossingMode },
- { "GdkModifierType", GTK_TYPE_FLAGS, enum_values_GdkModifierType },
- { "GdkSubwindowMode", GTK_TYPE_ENUM, enum_values_GdkSubwindowMode },
- { "GdkInputCondition", GTK_TYPE_FLAGS, enum_values_GdkInputCondition },
- { "GdkStatus", GTK_TYPE_ENUM, enum_values_GdkStatus },
- { "GdkByteOrder", GTK_TYPE_ENUM, enum_values_GdkByteOrder },
- { "GdkGCValuesMask", GTK_TYPE_FLAGS, enum_values_GdkGCValuesMask },
- { "GdkSelection", GTK_TYPE_ENUM, enum_values_GdkSelection },
- { "GdkPropertyState", GTK_TYPE_ENUM, enum_values_GdkPropertyState },
- { "GdkPropMode", GTK_TYPE_ENUM, enum_values_GdkPropMode },
- { "GdkDndType", GTK_TYPE_ENUM, enum_values_GdkDndType },
- { "GdkInputSource", GTK_TYPE_ENUM, enum_values_GdkInputSource },
- { "GdkInputMode", GTK_TYPE_ENUM, enum_values_GdkInputMode },
- { "GdkAxisUse", GTK_TYPE_ENUM, enum_values_GdkAxisUse },
- { "GdkTarget", GTK_TYPE_ENUM, enum_values_GdkTarget },
- { "GdkSelectionType", GTK_TYPE_ENUM, enum_values_GdkSelectionType },
- { "GdkExtensionMode", GTK_TYPE_ENUM, enum_values_GdkExtensionMode },
- { "GdkWMDecoration", GTK_TYPE_FLAGS, enum_values_GdkWMDecoration },
- { "GdkWMFunction", GTK_TYPE_FLAGS, enum_values_GdkWMFunction },
- { "GdkColorContextMode", GTK_TYPE_ENUM, enum_values_GdkColorContextMode },
- { "GdkOverlapType", GTK_TYPE_ENUM, enum_values_GdkOverlapType },
- { "GtkAccelFlags", GTK_TYPE_FLAGS, enum_values_GtkAccelFlags },
- { "GtkArrowType", GTK_TYPE_ENUM, enum_values_GtkArrowType },
- { "GtkAttachOptions", GTK_TYPE_FLAGS, enum_values_GtkAttachOptions },
- { "GtkButtonBoxStyle", GTK_TYPE_ENUM, enum_values_GtkButtonBoxStyle },
- { "GtkCurveType", GTK_TYPE_ENUM, enum_values_GtkCurveType },
- { "GtkDirectionType", GTK_TYPE_ENUM, enum_values_GtkDirectionType },
- { "GtkJustification", GTK_TYPE_ENUM, enum_values_GtkJustification },
- { "GtkMatchType", GTK_TYPE_ENUM, enum_values_GtkMatchType },
- { "GtkMenuFactoryType", GTK_TYPE_ENUM, enum_values_GtkMenuFactoryType },
- { "GtkMetricType", GTK_TYPE_ENUM, enum_values_GtkMetricType },
- { "GtkOrientation", GTK_TYPE_ENUM, enum_values_GtkOrientation },
- { "GtkPackType", GTK_TYPE_ENUM, enum_values_GtkPackType },
- { "GtkPathPriorityType", GTK_TYPE_ENUM, enum_values_GtkPathPriorityType },
- { "GtkPathType", GTK_TYPE_ENUM, enum_values_GtkPathType },
- { "GtkPolicyType", GTK_TYPE_ENUM, enum_values_GtkPolicyType },
- { "GtkPositionType", GTK_TYPE_ENUM, enum_values_GtkPositionType },
- { "GtkPreviewType", GTK_TYPE_ENUM, enum_values_GtkPreviewType },
- { "GtkReliefStyle", GTK_TYPE_ENUM, enum_values_GtkReliefStyle },
- { "GtkScrollType", GTK_TYPE_ENUM, enum_values_GtkScrollType },
- { "GtkSelectionMode", GTK_TYPE_ENUM, enum_values_GtkSelectionMode },
- { "GtkShadowType", GTK_TYPE_ENUM, enum_values_GtkShadowType },
- { "GtkSignalRunType", GTK_TYPE_FLAGS, enum_values_GtkSignalRunType },
- { "GtkStateType", GTK_TYPE_ENUM, enum_values_GtkStateType },
- { "GtkSubmenuDirection", GTK_TYPE_ENUM, enum_values_GtkSubmenuDirection },
- { "GtkSubmenuPlacement", GTK_TYPE_ENUM, enum_values_GtkSubmenuPlacement },
- { "GtkToolbarStyle", GTK_TYPE_ENUM, enum_values_GtkToolbarStyle },
- { "GtkTroughType", GTK_TYPE_ENUM, enum_values_GtkTroughType },
- { "GtkUpdateType", GTK_TYPE_ENUM, enum_values_GtkUpdateType },
- { "GtkVisibility", GTK_TYPE_ENUM, enum_values_GtkVisibility },
- { "GtkWindowPosition", GTK_TYPE_ENUM, enum_values_GtkWindowPosition },
- { "GtkWindowType", GTK_TYPE_ENUM, enum_values_GtkWindowType },
- { "GtkFundamentalType", GTK_TYPE_ENUM, enum_values_GtkFundamentalType },
- { "GtkDebugFlag", GTK_TYPE_FLAGS, enum_values_GtkDebugFlag },
- { "GtkObjectFlags", GTK_TYPE_FLAGS, enum_values_GtkObjectFlags },
- { "GtkArgFlags", GTK_TYPE_FLAGS, enum_values_GtkArgFlags },
- { "GtkWidgetFlags", GTK_TYPE_FLAGS, enum_values_GtkWidgetFlags },
- { "GtkPrivateFlags", GTK_TYPE_FLAGS, enum_values_GtkPrivateFlags },
- { "GdkDebugFlag", GTK_TYPE_FLAGS, enum_values_GdkDebugFlag },
- { "GtkAccelGroup", GTK_TYPE_BOXED, NULL },
- { "GtkStyle", GTK_TYPE_BOXED, NULL },
- { "GdkColormap", GTK_TYPE_BOXED, NULL },
- { "GdkVisual", GTK_TYPE_BOXED, NULL },
- { "GdkFont", GTK_TYPE_BOXED, NULL },
- { "GdkWindow", GTK_TYPE_BOXED, NULL },
- { "GdkEvent", GTK_TYPE_BOXED, NULL },
- { "GdkColor", GTK_TYPE_BOXED, NULL },
--- /dev/null
+/* generated by makeenums.awk */
+
+static GtkEnumValue _gdk_window_type_values[] = {
+ { GDK_WINDOW_ROOT, "GDK_WINDOW_ROOT", "root" },
+ { GDK_WINDOW_TOPLEVEL, "GDK_WINDOW_TOPLEVEL", "toplevel" },
+ { GDK_WINDOW_CHILD, "GDK_WINDOW_CHILD", "child" },
+ { GDK_WINDOW_DIALOG, "GDK_WINDOW_DIALOG", "dialog" },
+ { GDK_WINDOW_TEMP, "GDK_WINDOW_TEMP", "temp" },
+ { GDK_WINDOW_PIXMAP, "GDK_WINDOW_PIXMAP", "pixmap" },
+ { GDK_WINDOW_FOREIGN, "GDK_WINDOW_FOREIGN", "foreign" },
+};
+static GtkEnumValue _gdk_window_class_values[] = {
+ { GDK_INPUT_OUTPUT, "GDK_INPUT_OUTPUT", "input-output" },
+ { GDK_INPUT_ONLY, "GDK_INPUT_ONLY", "input-only" },
+};
+static GtkEnumValue _gdk_image_type_values[] = {
+ { GDK_IMAGE_NORMAL, "GDK_IMAGE_NORMAL", "normal" },
+ { GDK_IMAGE_SHARED, "GDK_IMAGE_SHARED", "shared" },
+ { GDK_IMAGE_FASTEST, "GDK_IMAGE_FASTEST", "fastest" },
+};
+static GtkEnumValue _gdk_visual_type_values[] = {
+ { GDK_VISUAL_STATIC_GRAY, "GDK_VISUAL_STATIC_GRAY", "static-gray" },
+ { GDK_VISUAL_GRAYSCALE, "GDK_VISUAL_GRAYSCALE", "grayscale" },
+ { GDK_VISUAL_STATIC_COLOR, "GDK_VISUAL_STATIC_COLOR", "static-color" },
+ { GDK_VISUAL_PSEUDO_COLOR, "GDK_VISUAL_PSEUDO_COLOR", "pseudo-color" },
+ { GDK_VISUAL_TRUE_COLOR, "GDK_VISUAL_TRUE_COLOR", "true-color" },
+ { GDK_VISUAL_DIRECT_COLOR, "GDK_VISUAL_DIRECT_COLOR", "direct-color" },
+};
+static GtkEnumValue _gdk_font_type_values[] = {
+ { GDK_FONT_FONT, "GDK_FONT_FONT", "font" },
+ { GDK_FONT_FONTSET, "GDK_FONT_FONTSET", "fontset" },
+};
+static GtkEnumValue _gdk_window_attributes_type_values[] = {
+ { GDK_WA_TITLE, "GDK_WA_TITLE", "title" },
+ { GDK_WA_X, "GDK_WA_X", "x" },
+ { GDK_WA_Y, "GDK_WA_Y", "y" },
+ { GDK_WA_CURSOR, "GDK_WA_CURSOR", "cursor" },
+ { GDK_WA_COLORMAP, "GDK_WA_COLORMAP", "colormap" },
+ { GDK_WA_VISUAL, "GDK_WA_VISUAL", "visual" },
+ { GDK_WA_WMCLASS, "GDK_WA_WMCLASS", "wmclass" },
+ { GDK_WA_NOREDIR, "GDK_WA_NOREDIR", "noredir" },
+};
+static GtkEnumValue _gdk_window_hints_values[] = {
+ { GDK_HINT_POS, "GDK_HINT_POS", "pos" },
+ { GDK_HINT_MIN_SIZE, "GDK_HINT_MIN_SIZE", "min-size" },
+ { GDK_HINT_MAX_SIZE, "GDK_HINT_MAX_SIZE", "max-size" },
+};
+static GtkEnumValue _gdk_function_values[] = {
+ { GDK_COPY, "GDK_COPY", "copy" },
+ { GDK_INVERT, "GDK_INVERT", "invert" },
+ { GDK_XOR, "GDK_XOR", "xor" },
+};
+static GtkEnumValue _gdk_fill_values[] = {
+ { GDK_SOLID, "GDK_SOLID", "solid" },
+ { GDK_TILED, "GDK_TILED", "tiled" },
+ { GDK_STIPPLED, "GDK_STIPPLED", "stippled" },
+ { GDK_OPAQUE_STIPPLED, "GDK_OPAQUE_STIPPLED", "opaque-stippled" },
+};
+static GtkEnumValue _gdk_fill_rule_values[] = {
+ { GDK_EVEN_ODD_RULE, "GDK_EVEN_ODD_RULE", "even-odd-rule" },
+ { GDK_WINDING_RULE, "GDK_WINDING_RULE", "winding-rule" },
+};
+static GtkEnumValue _gdk_line_style_values[] = {
+ { GDK_LINE_SOLID, "GDK_LINE_SOLID", "solid" },
+ { GDK_LINE_ON_OFF_DASH, "GDK_LINE_ON_OFF_DASH", "on-off-dash" },
+ { GDK_LINE_DOUBLE_DASH, "GDK_LINE_DOUBLE_DASH", "double-dash" },
+};
+static GtkEnumValue _gdk_cap_style_values[] = {
+ { GDK_CAP_NOT_LAST, "GDK_CAP_NOT_LAST", "not-last" },
+ { GDK_CAP_BUTT, "GDK_CAP_BUTT", "butt" },
+ { GDK_CAP_ROUND, "GDK_CAP_ROUND", "round" },
+ { GDK_CAP_PROJECTING, "GDK_CAP_PROJECTING", "projecting" },
+};
+static GtkEnumValue _gdk_join_style_values[] = {
+ { GDK_JOIN_MITER, "GDK_JOIN_MITER", "miter" },
+ { GDK_JOIN_ROUND, "GDK_JOIN_ROUND", "round" },
+ { GDK_JOIN_BEVEL, "GDK_JOIN_BEVEL", "bevel" },
+};
+static GtkEnumValue _gdk_filter_return_values[] = {
+ { GDK_FILTER_CONTINUE, "GDK_FILTER_CONTINUE", "continue" },
+ { GDK_FILTER_TRANSLATE, "GDK_FILTER_TRANSLATE", "translate" },
+ { GDK_FILTER_REMOVE, "GDK_FILTER_REMOVE", "remove" },
+};
+static GtkEnumValue _gdk_visibility_state_values[] = {
+ { GDK_VISIBILITY_UNOBSCURED, "GDK_VISIBILITY_UNOBSCURED", "unobscured" },
+ { GDK_VISIBILITY_PARTIAL, "GDK_VISIBILITY_PARTIAL", "partial" },
+ { GDK_VISIBILITY_FULLY_OBSCURED, "GDK_VISIBILITY_FULLY_OBSCURED", "fully-obscured" },
+};
+static GtkEnumValue _gdk_event_type_values[] = {
+ { GDK_NOTHING, "GDK_NOTHING", "nothing" },
+ { GDK_DELETE, "GDK_DELETE", "delete" },
+ { GDK_DESTROY, "GDK_DESTROY", "destroy" },
+ { GDK_EXPOSE, "GDK_EXPOSE", "expose" },
+ { GDK_MOTION_NOTIFY, "GDK_MOTION_NOTIFY", "motion-notify" },
+ { GDK_BUTTON_PRESS, "GDK_BUTTON_PRESS", "button-press" },
+ { GDK_2BUTTON_PRESS, "GDK_2BUTTON_PRESS", "2button-press" },
+ { GDK_3BUTTON_PRESS, "GDK_3BUTTON_PRESS", "3button-press" },
+ { GDK_BUTTON_RELEASE, "GDK_BUTTON_RELEASE", "button-release" },
+ { GDK_KEY_PRESS, "GDK_KEY_PRESS", "key-press" },
+ { GDK_KEY_RELEASE, "GDK_KEY_RELEASE", "key-release" },
+ { GDK_ENTER_NOTIFY, "GDK_ENTER_NOTIFY", "enter-notify" },
+ { GDK_LEAVE_NOTIFY, "GDK_LEAVE_NOTIFY", "leave-notify" },
+ { GDK_FOCUS_CHANGE, "GDK_FOCUS_CHANGE", "focus-change" },
+ { GDK_CONFIGURE, "GDK_CONFIGURE", "configure" },
+ { GDK_MAP, "GDK_MAP", "map" },
+ { GDK_UNMAP, "GDK_UNMAP", "unmap" },
+ { GDK_PROPERTY_NOTIFY, "GDK_PROPERTY_NOTIFY", "property-notify" },
+ { GDK_SELECTION_CLEAR, "GDK_SELECTION_CLEAR", "selection-clear" },
+ { GDK_SELECTION_REQUEST, "GDK_SELECTION_REQUEST", "selection-request" },
+ { GDK_SELECTION_NOTIFY, "GDK_SELECTION_NOTIFY", "selection-notify" },
+ { GDK_PROXIMITY_IN, "GDK_PROXIMITY_IN", "proximity-in" },
+ { GDK_PROXIMITY_OUT, "GDK_PROXIMITY_OUT", "proximity-out" },
+ { GDK_DRAG_BEGIN, "GDK_DRAG_BEGIN", "drag-begin" },
+ { GDK_DRAG_REQUEST, "GDK_DRAG_REQUEST", "drag-request" },
+ { GDK_DROP_ENTER, "GDK_DROP_ENTER", "drop-enter" },
+ { GDK_DROP_LEAVE, "GDK_DROP_LEAVE", "drop-leave" },
+ { GDK_DROP_DATA_AVAIL, "GDK_DROP_DATA_AVAIL", "drop-data-avail" },
+ { GDK_CLIENT_EVENT, "GDK_CLIENT_EVENT", "client-event" },
+ { GDK_VISIBILITY_NOTIFY, "GDK_VISIBILITY_NOTIFY", "visibility-notify" },
+ { GDK_NO_EXPOSE, "GDK_NO_EXPOSE", "no-expose" },
+ { GDK_OTHER_EVENT, "GDK_OTHER_EVENT", "other-event" },
+};
+static GtkEnumValue _gdk_event_mask_values[] = {
+ { GDK_EXPOSURE_MASK, "GDK_EXPOSURE_MASK", "exposure-mask" },
+ { GDK_POINTER_MOTION_MASK, "GDK_POINTER_MOTION_MASK", "pointer-motion-mask" },
+ { GDK_POINTER_MOTION_HINT_MASK, "GDK_POINTER_MOTION_HINT_MASK", "pointer-motion-hint-mask" },
+ { GDK_BUTTON_MOTION_MASK, "GDK_BUTTON_MOTION_MASK", "button-motion-mask" },
+ { GDK_BUTTON1_MOTION_MASK, "GDK_BUTTON1_MOTION_MASK", "button1-motion-mask" },
+ { GDK_BUTTON2_MOTION_MASK, "GDK_BUTTON2_MOTION_MASK", "button2-motion-mask" },
+ { GDK_BUTTON3_MOTION_MASK, "GDK_BUTTON3_MOTION_MASK", "button3-motion-mask" },
+ { GDK_BUTTON_PRESS_MASK, "GDK_BUTTON_PRESS_MASK", "button-press-mask" },
+ { GDK_BUTTON_RELEASE_MASK, "GDK_BUTTON_RELEASE_MASK", "button-release-mask" },
+ { GDK_KEY_PRESS_MASK, "GDK_KEY_PRESS_MASK", "key-press-mask" },
+ { GDK_KEY_RELEASE_MASK, "GDK_KEY_RELEASE_MASK", "key-release-mask" },
+ { GDK_ENTER_NOTIFY_MASK, "GDK_ENTER_NOTIFY_MASK", "enter-notify-mask" },
+ { GDK_LEAVE_NOTIFY_MASK, "GDK_LEAVE_NOTIFY_MASK", "leave-notify-mask" },
+ { GDK_FOCUS_CHANGE_MASK, "GDK_FOCUS_CHANGE_MASK", "focus-change-mask" },
+ { GDK_STRUCTURE_MASK, "GDK_STRUCTURE_MASK", "structure-mask" },
+ { GDK_PROPERTY_CHANGE_MASK, "GDK_PROPERTY_CHANGE_MASK", "property-change-mask" },
+ { GDK_VISIBILITY_NOTIFY_MASK, "GDK_VISIBILITY_NOTIFY_MASK", "visibility-notify-mask" },
+ { GDK_PROXIMITY_IN_MASK, "GDK_PROXIMITY_IN_MASK", "proximity-in-mask" },
+ { GDK_PROXIMITY_OUT_MASK, "GDK_PROXIMITY_OUT_MASK", "proximity-out-mask" },
+ { GDK_SUBSTRUCTURE_MASK, "GDK_SUBSTRUCTURE_MASK", "substructure-mask" },
+ { GDK_ALL_EVENTS_MASK, "GDK_ALL_EVENTS_MASK", "all-events-mask" },
+};
+static GtkEnumValue _gdk_notify_type_values[] = {
+ { GDK_NOTIFY_ANCESTOR, "GDK_NOTIFY_ANCESTOR", "ancestor" },
+ { GDK_NOTIFY_VIRTUAL, "GDK_NOTIFY_VIRTUAL", "virtual" },
+ { GDK_NOTIFY_INFERIOR, "GDK_NOTIFY_INFERIOR", "inferior" },
+ { GDK_NOTIFY_NONLINEAR, "GDK_NOTIFY_NONLINEAR", "nonlinear" },
+ { GDK_NOTIFY_NONLINEAR_VIRTUAL, "GDK_NOTIFY_NONLINEAR_VIRTUAL", "nonlinear-virtual" },
+ { GDK_NOTIFY_UNKNOWN, "GDK_NOTIFY_UNKNOWN", "unknown" },
+};
+static GtkEnumValue _gdk_crossing_mode_values[] = {
+ { GDK_CROSSING_NORMAL, "GDK_CROSSING_NORMAL", "crossing-normal" },
+ { GDK_CROSSING_GRAB, "GDK_CROSSING_GRAB", "crossing-grab" },
+ { GDK_CROSSING_UNGRAB, "GDK_CROSSING_UNGRAB", "crossing-ungrab" },
+};
+static GtkEnumValue _gdk_modifier_type_values[] = {
+ { GDK_SHIFT_MASK, "GDK_SHIFT_MASK", "shift-mask" },
+ { GDK_LOCK_MASK, "GDK_LOCK_MASK", "lock-mask" },
+ { GDK_CONTROL_MASK, "GDK_CONTROL_MASK", "control-mask" },
+ { GDK_MOD1_MASK, "GDK_MOD1_MASK", "mod1-mask" },
+ { GDK_MOD2_MASK, "GDK_MOD2_MASK", "mod2-mask" },
+ { GDK_MOD3_MASK, "GDK_MOD3_MASK", "mod3-mask" },
+ { GDK_MOD4_MASK, "GDK_MOD4_MASK", "mod4-mask" },
+ { GDK_MOD5_MASK, "GDK_MOD5_MASK", "mod5-mask" },
+ { GDK_BUTTON1_MASK, "GDK_BUTTON1_MASK", "button1-mask" },
+ { GDK_BUTTON2_MASK, "GDK_BUTTON2_MASK", "button2-mask" },
+ { GDK_BUTTON3_MASK, "GDK_BUTTON3_MASK", "button3-mask" },
+ { GDK_BUTTON4_MASK, "GDK_BUTTON4_MASK", "button4-mask" },
+ { GDK_BUTTON5_MASK, "GDK_BUTTON5_MASK", "button5-mask" },
+ { GDK_MODIFIER_MASK, "GDK_MODIFIER_MASK", "modifier-mask" },
+};
+static GtkEnumValue _gdk_subwindow_mode_values[] = {
+ { GDK_CLIP_BY_CHILDREN, "GDK_CLIP_BY_CHILDREN", "clip-by-children" },
+ { GDK_INCLUDE_INFERIORS, "GDK_INCLUDE_INFERIORS", "include-inferiors" },
+};
+static GtkEnumValue _gdk_input_condition_values[] = {
+ { GDK_INPUT_READ, "GDK_INPUT_READ", "read" },
+ { GDK_INPUT_WRITE, "GDK_INPUT_WRITE", "write" },
+ { GDK_INPUT_EXCEPTION, "GDK_INPUT_EXCEPTION", "exception" },
+};
+static GtkEnumValue _gdk_status_values[] = {
+ { GDK_OK, "GDK_OK", "ok" },
+ { GDK_ERROR, "GDK_ERROR", "error" },
+ { GDK_ERROR_PARAM, "GDK_ERROR_PARAM", "error-param" },
+ { GDK_ERROR_FILE, "GDK_ERROR_FILE", "error-file" },
+ { GDK_ERROR_MEM, "GDK_ERROR_MEM", "error-mem" },
+};
+static GtkEnumValue _gdk_byte_order_values[] = {
+ { GDK_LSB_FIRST, "GDK_LSB_FIRST", "lsb-first" },
+ { GDK_MSB_FIRST, "GDK_MSB_FIRST", "msb-first" },
+};
+static GtkEnumValue _gdk_g_c_values_mask_values[] = {
+ { GDK_GC_FOREGROUND, "GDK_GC_FOREGROUND", "foreground" },
+ { GDK_GC_BACKGROUND, "GDK_GC_BACKGROUND", "background" },
+ { GDK_GC_FONT, "GDK_GC_FONT", "font" },
+ { GDK_GC_FUNCTION, "GDK_GC_FUNCTION", "function" },
+ { GDK_GC_FILL, "GDK_GC_FILL", "fill" },
+ { GDK_GC_TILE, "GDK_GC_TILE", "tile" },
+ { GDK_GC_STIPPLE, "GDK_GC_STIPPLE", "stipple" },
+ { GDK_GC_CLIP_MASK, "GDK_GC_CLIP_MASK", "clip-mask" },
+ { GDK_GC_SUBWINDOW, "GDK_GC_SUBWINDOW", "subwindow" },
+ { GDK_GC_TS_X_ORIGIN, "GDK_GC_TS_X_ORIGIN", "ts-x-origin" },
+ { GDK_GC_TS_Y_ORIGIN, "GDK_GC_TS_Y_ORIGIN", "ts-y-origin" },
+ { GDK_GC_CLIP_X_ORIGIN, "GDK_GC_CLIP_X_ORIGIN", "clip-x-origin" },
+ { GDK_GC_CLIP_Y_ORIGIN, "GDK_GC_CLIP_Y_ORIGIN", "clip-y-origin" },
+ { GDK_GC_EXPOSURES, "GDK_GC_EXPOSURES", "exposures" },
+ { GDK_GC_LINE_WIDTH, "GDK_GC_LINE_WIDTH", "line-width" },
+ { GDK_GC_LINE_STYLE, "GDK_GC_LINE_STYLE", "line-style" },
+ { GDK_GC_CAP_STYLE, "GDK_GC_CAP_STYLE", "cap-style" },
+ { GDK_GC_JOIN_STYLE, "GDK_GC_JOIN_STYLE", "join-style" },
+};
+static GtkEnumValue _gdk_selection_values[] = {
+ { GDK_SELECTION_PRIMARY, "GDK_SELECTION_PRIMARY", "primary" },
+ { GDK_SELECTION_SECONDARY, "GDK_SELECTION_SECONDARY", "secondary" },
+};
+static GtkEnumValue _gdk_property_state_values[] = {
+ { GDK_PROPERTY_NEW_VALUE, "GDK_PROPERTY_NEW_VALUE", "new-value" },
+ { GDK_PROPERTY_DELETE, "GDK_PROPERTY_DELETE", "delete" },
+};
+static GtkEnumValue _gdk_prop_mode_values[] = {
+ { GDK_PROP_MODE_REPLACE, "GDK_PROP_MODE_REPLACE", "replace" },
+ { GDK_PROP_MODE_PREPEND, "GDK_PROP_MODE_PREPEND", "prepend" },
+ { GDK_PROP_MODE_APPEND, "GDK_PROP_MODE_APPEND", "append" },
+};
+static GtkEnumValue _gdk_dnd_type_values[] = {
+ { GDK_DNDTYPE_NOTDND, "GDK_DNDTYPE_NOTDND", "notdnd" },
+ { GDK_DNDTYPE_UNKNOWN, "GDK_DNDTYPE_UNKNOWN", "unknown" },
+ { GDK_DNDTYPE_RAWDATA, "GDK_DNDTYPE_RAWDATA", "rawdata" },
+ { GDK_DNDTYPE_FILE, "GDK_DNDTYPE_FILE", "file" },
+ { GDK_DNDTYPE_FILES, "GDK_DNDTYPE_FILES", "files" },
+ { GDK_DNDTYPE_TEXT, "GDK_DNDTYPE_TEXT", "text" },
+ { GDK_DNDTYPE_DIR, "GDK_DNDTYPE_DIR", "dir" },
+ { GDK_DNDTYPE_LINK, "GDK_DNDTYPE_LINK", "link" },
+ { GDK_DNDTYPE_EXE, "GDK_DNDTYPE_EXE", "exe" },
+ { GDK_DNDTYPE_URL, "GDK_DNDTYPE_URL", "url" },
+ { GDK_DNDTYPE_MIME, "GDK_DNDTYPE_MIME", "mime" },
+ { GDK_DNDTYPE_END, "GDK_DNDTYPE_END", "end" },
+};
+static GtkEnumValue _gdk_input_source_values[] = {
+ { GDK_SOURCE_MOUSE, "GDK_SOURCE_MOUSE", "mouse" },
+ { GDK_SOURCE_PEN, "GDK_SOURCE_PEN", "pen" },
+ { GDK_SOURCE_ERASER, "GDK_SOURCE_ERASER", "eraser" },
+ { GDK_SOURCE_CURSOR, "GDK_SOURCE_CURSOR", "cursor" },
+};
+static GtkEnumValue _gdk_input_mode_values[] = {
+ { GDK_MODE_DISABLED, "GDK_MODE_DISABLED", "disabled" },
+ { GDK_MODE_SCREEN, "GDK_MODE_SCREEN", "screen" },
+ { GDK_MODE_WINDOW, "GDK_MODE_WINDOW", "window" },
+};
+static GtkEnumValue _gdk_axis_use_values[] = {
+ { GDK_AXIS_IGNORE, "GDK_AXIS_IGNORE", "ignore" },
+ { GDK_AXIS_X, "GDK_AXIS_X", "x" },
+ { GDK_AXIS_Y, "GDK_AXIS_Y", "y" },
+ { GDK_AXIS_PRESSURE, "GDK_AXIS_PRESSURE", "pressure" },
+ { GDK_AXIS_XTILT, "GDK_AXIS_XTILT", "xtilt" },
+ { GDK_AXIS_YTILT, "GDK_AXIS_YTILT", "ytilt" },
+ { GDK_AXIS_LAST, "GDK_AXIS_LAST", "last" },
+};
+static GtkEnumValue _gdk_target_values[] = {
+ { GDK_TARGET_BITMAP, "GDK_TARGET_BITMAP", "bitmap" },
+ { GDK_TARGET_COLORMAP, "GDK_TARGET_COLORMAP", "colormap" },
+ { GDK_TARGET_DRAWABLE, "GDK_TARGET_DRAWABLE", "drawable" },
+ { GDK_TARGET_PIXMAP, "GDK_TARGET_PIXMAP", "pixmap" },
+ { GDK_TARGET_STRING, "GDK_TARGET_STRING", "string" },
+};
+static GtkEnumValue _gdk_selection_type_values[] = {
+ { GDK_SELECTION_TYPE_ATOM, "GDK_SELECTION_TYPE_ATOM", "atom" },
+ { GDK_SELECTION_TYPE_BITMAP, "GDK_SELECTION_TYPE_BITMAP", "bitmap" },
+ { GDK_SELECTION_TYPE_COLORMAP, "GDK_SELECTION_TYPE_COLORMAP", "colormap" },
+ { GDK_SELECTION_TYPE_DRAWABLE, "GDK_SELECTION_TYPE_DRAWABLE", "drawable" },
+ { GDK_SELECTION_TYPE_INTEGER, "GDK_SELECTION_TYPE_INTEGER", "integer" },
+ { GDK_SELECTION_TYPE_PIXMAP, "GDK_SELECTION_TYPE_PIXMAP", "pixmap" },
+ { GDK_SELECTION_TYPE_WINDOW, "GDK_SELECTION_TYPE_WINDOW", "window" },
+ { GDK_SELECTION_TYPE_STRING, "GDK_SELECTION_TYPE_STRING", "string" },
+};
+static GtkEnumValue _gdk_extension_mode_values[] = {
+ { GDK_EXTENSION_EVENTS_NONE, "GDK_EXTENSION_EVENTS_NONE", "none" },
+ { GDK_EXTENSION_EVENTS_ALL, "GDK_EXTENSION_EVENTS_ALL", "all" },
+ { GDK_EXTENSION_EVENTS_CURSOR, "GDK_EXTENSION_EVENTS_CURSOR", "cursor" },
+};
+static GtkEnumValue _gdk_w_m_decoration_values[] = {
+ { GDK_DECOR_ALL, "GDK_DECOR_ALL", "all" },
+ { GDK_DECOR_BORDER, "GDK_DECOR_BORDER", "border" },
+ { GDK_DECOR_RESIZEH, "GDK_DECOR_RESIZEH", "resizeh" },
+ { GDK_DECOR_TITLE, "GDK_DECOR_TITLE", "title" },
+ { GDK_DECOR_MENU, "GDK_DECOR_MENU", "menu" },
+ { GDK_DECOR_MINIMIZE, "GDK_DECOR_MINIMIZE", "minimize" },
+ { GDK_DECOR_MAXIMIZE, "GDK_DECOR_MAXIMIZE", "maximize" },
+};
+static GtkEnumValue _gdk_w_m_function_values[] = {
+ { GDK_FUNC_ALL, "GDK_FUNC_ALL", "all" },
+ { GDK_FUNC_RESIZE, "GDK_FUNC_RESIZE", "resize" },
+ { GDK_FUNC_MOVE, "GDK_FUNC_MOVE", "move" },
+ { GDK_FUNC_MINIMIZE, "GDK_FUNC_MINIMIZE", "minimize" },
+ { GDK_FUNC_MAXIMIZE, "GDK_FUNC_MAXIMIZE", "maximize" },
+ { GDK_FUNC_CLOSE, "GDK_FUNC_CLOSE", "close" },
+};
+static GtkEnumValue _gdk_color_context_mode_values[] = {
+ { GDK_CC_MODE_UNDEFINED, "GDK_CC_MODE_UNDEFINED", "undefined" },
+ { GDK_CC_MODE_BW, "GDK_CC_MODE_BW", "bw" },
+ { GDK_CC_MODE_STD_CMAP, "GDK_CC_MODE_STD_CMAP", "std-cmap" },
+ { GDK_CC_MODE_TRUE, "GDK_CC_MODE_TRUE", "true" },
+ { GDK_CC_MODE_MY_GRAY, "GDK_CC_MODE_MY_GRAY", "my-gray" },
+ { GDK_CC_MODE_PALETTE, "GDK_CC_MODE_PALETTE", "palette" },
+};
+static GtkEnumValue _gdk_overlap_type_values[] = {
+ { GDK_OVERLAP_RECTANGLE_IN, "GDK_OVERLAP_RECTANGLE_IN", "in" },
+ { GDK_OVERLAP_RECTANGLE_OUT, "GDK_OVERLAP_RECTANGLE_OUT", "out" },
+ { GDK_OVERLAP_RECTANGLE_PART, "GDK_OVERLAP_RECTANGLE_PART", "part" },
+};
+static GtkEnumValue _gdk_debug_flag_values[] = {
+ { GDK_DEBUG_MISC, "GDK_DEBUG_MISC", "misc" },
+ { GDK_DEBUG_EVENTS, "GDK_DEBUG_EVENTS", "events" },
+ { GDK_DEBUG_DND, "GDK_DEBUG_DND", "dnd" },
+ { GDK_DEBUG_COLOR_CONTEXT, "GDK_DEBUG_COLOR_CONTEXT", "color-context" },
+ { GDK_DEBUG_XIM, "GDK_DEBUG_XIM", "xim" },
+};
+static GtkEnumValue _gtk_accel_flags_values[] = {
+ { GTK_ACCEL_VISIBLE, "GTK_ACCEL_VISIBLE", "visible" },
+ { GTK_ACCEL_SIGNAL_VISIBLE, "GTK_ACCEL_SIGNAL_VISIBLE", "signal-visible" },
+ { GTK_ACCEL_LOCKED, "GTK_ACCEL_LOCKED", "locked" },
+ { GTK_ACCEL_MASK, "GTK_ACCEL_MASK", "mask" },
+};
+static GtkEnumValue _gtk_arrow_type_values[] = {
+ { GTK_ARROW_UP, "GTK_ARROW_UP", "up" },
+ { GTK_ARROW_DOWN, "GTK_ARROW_DOWN", "down" },
+ { GTK_ARROW_LEFT, "GTK_ARROW_LEFT", "left" },
+ { GTK_ARROW_RIGHT, "GTK_ARROW_RIGHT", "right" },
+};
+static GtkEnumValue _gtk_attach_options_values[] = {
+ { GTK_EXPAND, "GTK_EXPAND", "expand" },
+ { GTK_SHRINK, "GTK_SHRINK", "shrink" },
+ { GTK_FILL, "GTK_FILL", "fill" },
+};
+static GtkEnumValue _gtk_button_box_style_values[] = {
+ { GTK_BUTTONBOX_DEFAULT_STYLE, "GTK_BUTTONBOX_DEFAULT_STYLE", "default" },
+ { GTK_BUTTONBOX_SPREAD, "GTK_BUTTONBOX_SPREAD", "spread" },
+ { GTK_BUTTONBOX_EDGE, "GTK_BUTTONBOX_EDGE", "edge" },
+ { GTK_BUTTONBOX_START, "GTK_BUTTONBOX_START", "start" },
+ { GTK_BUTTONBOX_END, "GTK_BUTTONBOX_END", "end" },
+};
+static GtkEnumValue _gtk_curve_type_values[] = {
+ { GTK_CURVE_TYPE_LINEAR, "GTK_CURVE_TYPE_LINEAR", "linear" },
+ { GTK_CURVE_TYPE_SPLINE, "GTK_CURVE_TYPE_SPLINE", "spline" },
+ { GTK_CURVE_TYPE_FREE, "GTK_CURVE_TYPE_FREE", "free" },
+};
+static GtkEnumValue _gtk_direction_type_values[] = {
+ { GTK_DIR_TAB_FORWARD, "GTK_DIR_TAB_FORWARD", "tab-forward" },
+ { GTK_DIR_TAB_BACKWARD, "GTK_DIR_TAB_BACKWARD", "tab-backward" },
+ { GTK_DIR_UP, "GTK_DIR_UP", "up" },
+ { GTK_DIR_DOWN, "GTK_DIR_DOWN", "down" },
+ { GTK_DIR_LEFT, "GTK_DIR_LEFT", "left" },
+ { GTK_DIR_RIGHT, "GTK_DIR_RIGHT", "right" },
+};
+static GtkEnumValue _gtk_justification_values[] = {
+ { GTK_JUSTIFY_LEFT, "GTK_JUSTIFY_LEFT", "left" },
+ { GTK_JUSTIFY_RIGHT, "GTK_JUSTIFY_RIGHT", "right" },
+ { GTK_JUSTIFY_CENTER, "GTK_JUSTIFY_CENTER", "center" },
+ { GTK_JUSTIFY_FILL, "GTK_JUSTIFY_FILL", "fill" },
+};
+static GtkEnumValue _gtk_match_type_values[] = {
+ { GTK_MATCH_ALL, "GTK_MATCH_ALL", "all" },
+ { GTK_MATCH_ALL_TAIL, "GTK_MATCH_ALL_TAIL", "all-tail" },
+ { GTK_MATCH_HEAD, "GTK_MATCH_HEAD", "head" },
+ { GTK_MATCH_TAIL, "GTK_MATCH_TAIL", "tail" },
+ { GTK_MATCH_EXACT, "GTK_MATCH_EXACT", "exact" },
+ { GTK_MATCH_LAST, "GTK_MATCH_LAST", "last" },
+};
+static GtkEnumValue _gtk_menu_factory_type_values[] = {
+ { GTK_MENU_FACTORY_MENU, "GTK_MENU_FACTORY_MENU", "menu" },
+ { GTK_MENU_FACTORY_MENU_BAR, "GTK_MENU_FACTORY_MENU_BAR", "menu-bar" },
+ { GTK_MENU_FACTORY_OPTION_MENU, "GTK_MENU_FACTORY_OPTION_MENU", "option-menu" },
+};
+static GtkEnumValue _gtk_metric_type_values[] = {
+ { GTK_PIXELS, "GTK_PIXELS", "pixels" },
+ { GTK_INCHES, "GTK_INCHES", "inches" },
+ { GTK_CENTIMETERS, "GTK_CENTIMETERS", "centimeters" },
+};
+static GtkEnumValue _gtk_orientation_values[] = {
+ { GTK_ORIENTATION_HORIZONTAL, "GTK_ORIENTATION_HORIZONTAL", "horizontal" },
+ { GTK_ORIENTATION_VERTICAL, "GTK_ORIENTATION_VERTICAL", "vertical" },
+};
+static GtkEnumValue _gtk_pack_type_values[] = {
+ { GTK_PACK_START, "GTK_PACK_START", "start" },
+ { GTK_PACK_END, "GTK_PACK_END", "end" },
+};
+static GtkEnumValue _gtk_path_priority_type_values[] = {
+ { GTK_PATH_PRIO_LOWEST, "GTK_PATH_PRIO_LOWEST", "lowest" },
+ { GTK_PATH_PRIO_GTK, "GTK_PATH_PRIO_GTK", "gtk" },
+ { GTK_PATH_PRIO_APPLICATION, "GTK_PATH_PRIO_APPLICATION", "application" },
+ { GTK_PATH_PRIO_RC, "GTK_PATH_PRIO_RC", "rc" },
+ { GTK_PATH_PRIO_HIGHEST, "GTK_PATH_PRIO_HIGHEST", "highest" },
+ { GTK_PATH_PRIO_MASK, "GTK_PATH_PRIO_MASK", "mask" },
+};
+static GtkEnumValue _gtk_path_type_values[] = {
+ { GTK_PATH_WIDGET, "GTK_PATH_WIDGET", "widget" },
+ { GTK_PATH_WIDGET_CLASS, "GTK_PATH_WIDGET_CLASS", "widget-class" },
+ { GTK_PATH_CLASS, "GTK_PATH_CLASS", "class" },
+};
+static GtkEnumValue _gtk_policy_type_values[] = {
+ { GTK_POLICY_ALWAYS, "GTK_POLICY_ALWAYS", "always" },
+ { GTK_POLICY_AUTOMATIC, "GTK_POLICY_AUTOMATIC", "automatic" },
+};
+static GtkEnumValue _gtk_position_type_values[] = {
+ { GTK_POS_LEFT, "GTK_POS_LEFT", "left" },
+ { GTK_POS_RIGHT, "GTK_POS_RIGHT", "right" },
+ { GTK_POS_TOP, "GTK_POS_TOP", "top" },
+ { GTK_POS_BOTTOM, "GTK_POS_BOTTOM", "bottom" },
+};
+static GtkEnumValue _gtk_preview_type_values[] = {
+ { GTK_PREVIEW_COLOR, "GTK_PREVIEW_COLOR", "color" },
+ { GTK_PREVIEW_GRAYSCALE, "GTK_PREVIEW_GRAYSCALE", "grayscale" },
+ { GTK_PREVIEW_GREYSCALE, "GTK_PREVIEW_GREYSCALE", "greyscale" },
+};
+static GtkEnumValue _gtk_relief_style_values[] = {
+ { GTK_RELIEF_NORMAL, "GTK_RELIEF_NORMAL", "normal" },
+ { GTK_RELIEF_NONE, "GTK_RELIEF_NONE", "none" },
+};
+static GtkEnumValue _gtk_scroll_type_values[] = {
+ { GTK_SCROLL_NONE, "GTK_SCROLL_NONE", "none" },
+ { GTK_SCROLL_STEP_BACKWARD, "GTK_SCROLL_STEP_BACKWARD", "step-backward" },
+ { GTK_SCROLL_STEP_FORWARD, "GTK_SCROLL_STEP_FORWARD", "step-forward" },
+ { GTK_SCROLL_PAGE_BACKWARD, "GTK_SCROLL_PAGE_BACKWARD", "page-backward" },
+ { GTK_SCROLL_PAGE_FORWARD, "GTK_SCROLL_PAGE_FORWARD", "page-forward" },
+ { GTK_SCROLL_JUMP, "GTK_SCROLL_JUMP", "jump" },
+};
+static GtkEnumValue _gtk_selection_mode_values[] = {
+ { GTK_SELECTION_SINGLE, "GTK_SELECTION_SINGLE", "single" },
+ { GTK_SELECTION_BROWSE, "GTK_SELECTION_BROWSE", "browse" },
+ { GTK_SELECTION_MULTIPLE, "GTK_SELECTION_MULTIPLE", "multiple" },
+ { GTK_SELECTION_EXTENDED, "GTK_SELECTION_EXTENDED", "extended" },
+};
+static GtkEnumValue _gtk_shadow_type_values[] = {
+ { GTK_SHADOW_NONE, "GTK_SHADOW_NONE", "none" },
+ { GTK_SHADOW_IN, "GTK_SHADOW_IN", "in" },
+ { GTK_SHADOW_OUT, "GTK_SHADOW_OUT", "out" },
+ { GTK_SHADOW_ETCHED_IN, "GTK_SHADOW_ETCHED_IN", "etched-in" },
+ { GTK_SHADOW_ETCHED_OUT, "GTK_SHADOW_ETCHED_OUT", "etched-out" },
+};
+static GtkEnumValue _gtk_signal_run_type_values[] = {
+ { GTK_RUN_FIRST, "GTK_RUN_FIRST", "first" },
+ { GTK_RUN_LAST, "GTK_RUN_LAST", "last" },
+ { GTK_RUN_BOTH, "GTK_RUN_BOTH", "both" },
+ { GTK_RUN_MASK, "GTK_RUN_MASK", "mask" },
+ { GTK_RUN_NO_RECURSE, "GTK_RUN_NO_RECURSE", "no-recurse" },
+ { GTK_RUN_ACTION, "GTK_RUN_ACTION", "action" },
+};
+static GtkEnumValue _gtk_state_type_values[] = {
+ { GTK_STATE_NORMAL, "GTK_STATE_NORMAL", "normal" },
+ { GTK_STATE_ACTIVE, "GTK_STATE_ACTIVE", "active" },
+ { GTK_STATE_PRELIGHT, "GTK_STATE_PRELIGHT", "prelight" },
+ { GTK_STATE_SELECTED, "GTK_STATE_SELECTED", "selected" },
+ { GTK_STATE_INSENSITIVE, "GTK_STATE_INSENSITIVE", "insensitive" },
+};
+static GtkEnumValue _gtk_submenu_direction_values[] = {
+ { GTK_DIRECTION_LEFT, "GTK_DIRECTION_LEFT", "left" },
+ { GTK_DIRECTION_RIGHT, "GTK_DIRECTION_RIGHT", "right" },
+};
+static GtkEnumValue _gtk_submenu_placement_values[] = {
+ { GTK_TOP_BOTTOM, "GTK_TOP_BOTTOM", "top-bottom" },
+ { GTK_LEFT_RIGHT, "GTK_LEFT_RIGHT", "left-right" },
+};
+static GtkEnumValue _gtk_toolbar_style_values[] = {
+ { GTK_TOOLBAR_ICONS, "GTK_TOOLBAR_ICONS", "icons" },
+ { GTK_TOOLBAR_TEXT, "GTK_TOOLBAR_TEXT", "text" },
+ { GTK_TOOLBAR_BOTH, "GTK_TOOLBAR_BOTH", "both" },
+};
+static GtkEnumValue _gtk_trough_type_values[] = {
+ { GTK_TROUGH_NONE, "GTK_TROUGH_NONE", "none" },
+ { GTK_TROUGH_START, "GTK_TROUGH_START", "start" },
+ { GTK_TROUGH_END, "GTK_TROUGH_END", "end" },
+ { GTK_TROUGH_JUMP, "GTK_TROUGH_JUMP", "jump" },
+};
+static GtkEnumValue _gtk_update_type_values[] = {
+ { GTK_UPDATE_CONTINUOUS, "GTK_UPDATE_CONTINUOUS", "continuous" },
+ { GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" },
+ { GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" },
+};
+static GtkEnumValue _gtk_visibility_values[] = {
+ { GTK_VISIBILITY_NONE, "GTK_VISIBILITY_NONE", "none" },
+ { GTK_VISIBILITY_PARTIAL, "GTK_VISIBILITY_PARTIAL", "partial" },
+ { GTK_VISIBILITY_FULL, "GTK_VISIBILITY_FULL", "full" },
+};
+static GtkEnumValue _gtk_window_position_values[] = {
+ { GTK_WIN_POS_NONE, "GTK_WIN_POS_NONE", "none" },
+ { GTK_WIN_POS_CENTER, "GTK_WIN_POS_CENTER", "center" },
+ { GTK_WIN_POS_MOUSE, "GTK_WIN_POS_MOUSE", "mouse" },
+};
+static GtkEnumValue _gtk_window_type_values[] = {
+ { GTK_WINDOW_TOPLEVEL, "GTK_WINDOW_TOPLEVEL", "toplevel" },
+ { GTK_WINDOW_DIALOG, "GTK_WINDOW_DIALOG", "dialog" },
+ { GTK_WINDOW_POPUP, "GTK_WINDOW_POPUP", "popup" },
+};
+static GtkEnumValue _gtk_fundamental_type_values[] = {
+ { GTK_TYPE_INVALID, "GTK_TYPE_INVALID", "invalid" },
+ { GTK_TYPE_NONE, "GTK_TYPE_NONE", "none" },
+ { GTK_TYPE_CHAR, "GTK_TYPE_CHAR", "char" },
+ { GTK_TYPE_BOOL, "GTK_TYPE_BOOL", "bool" },
+ { GTK_TYPE_INT, "GTK_TYPE_INT", "int" },
+ { GTK_TYPE_UINT, "GTK_TYPE_UINT", "uint" },
+ { GTK_TYPE_LONG, "GTK_TYPE_LONG", "long" },
+ { GTK_TYPE_ULONG, "GTK_TYPE_ULONG", "ulong" },
+ { GTK_TYPE_FLOAT, "GTK_TYPE_FLOAT", "float" },
+ { GTK_TYPE_DOUBLE, "GTK_TYPE_DOUBLE", "double" },
+ { GTK_TYPE_STRING, "GTK_TYPE_STRING", "string" },
+ { GTK_TYPE_ENUM, "GTK_TYPE_ENUM", "enum" },
+ { GTK_TYPE_FLAGS, "GTK_TYPE_FLAGS", "flags" },
+ { GTK_TYPE_BOXED, "GTK_TYPE_BOXED", "boxed" },
+ { GTK_TYPE_FOREIGN, "GTK_TYPE_FOREIGN", "foreign" },
+ { GTK_TYPE_CALLBACK, "GTK_TYPE_CALLBACK", "callback" },
+ { GTK_TYPE_ARGS, "GTK_TYPE_ARGS", "args" },
+ { GTK_TYPE_POINTER, "GTK_TYPE_POINTER", "pointer" },
+ { GTK_TYPE_SIGNAL, "GTK_TYPE_SIGNAL", "signal" },
+ { GTK_TYPE_C_CALLBACK, "GTK_TYPE_C_CALLBACK", "c-callback" },
+ { GTK_TYPE_OBJECT, "GTK_TYPE_OBJECT", "object" },
+};
+static GtkEnumValue _gtk_debug_flag_values[] = {
+ { GTK_DEBUG_OBJECTS, "GTK_DEBUG_OBJECTS", "objects" },
+ { GTK_DEBUG_MISC, "GTK_DEBUG_MISC", "misc" },
+ { GTK_DEBUG_SIGNALS, "GTK_DEBUG_SIGNALS", "signals" },
+};
+static GtkEnumValue _gtk_object_flags_values[] = {
+ { GTK_DESTROYED, "GTK_DESTROYED", "destroyed" },
+ { GTK_FLOATING, "GTK_FLOATING", "floating" },
+ { GTK_CONNECTED, "GTK_CONNECTED", "connected" },
+ { GTK_OBJECT_FLAG_LAST, "GTK_OBJECT_FLAG_LAST", "object-flag-last" },
+};
+static GtkEnumValue _gtk_arg_flags_values[] = {
+ { GTK_ARG_READABLE, "GTK_ARG_READABLE", "readable" },
+ { GTK_ARG_WRITABLE, "GTK_ARG_WRITABLE", "writable" },
+ { GTK_ARG_CONSTRUCT, "GTK_ARG_CONSTRUCT", "construct" },
+ { GTK_ARG_MASK, "GTK_ARG_MASK", "mask" },
+ { GTK_ARG_READWRITE, "GTK_ARG_READWRITE", "readwrite" },
+};
+static GtkEnumValue _gtk_widget_flags_values[] = {
+ { GTK_TOPLEVEL, "GTK_TOPLEVEL", "toplevel" },
+ { GTK_NO_WINDOW, "GTK_NO_WINDOW", "no-window" },
+ { GTK_REALIZED, "GTK_REALIZED", "realized" },
+ { GTK_MAPPED, "GTK_MAPPED", "mapped" },
+ { GTK_VISIBLE, "GTK_VISIBLE", "visible" },
+ { GTK_SENSITIVE, "GTK_SENSITIVE", "sensitive" },
+ { GTK_PARENT_SENSITIVE, "GTK_PARENT_SENSITIVE", "parent-sensitive" },
+ { GTK_CAN_FOCUS, "GTK_CAN_FOCUS", "can-focus" },
+ { GTK_HAS_FOCUS, "GTK_HAS_FOCUS", "has-focus" },
+ { GTK_CAN_DEFAULT, "GTK_CAN_DEFAULT", "can-default" },
+ { GTK_HAS_DEFAULT, "GTK_HAS_DEFAULT", "has-default" },
+ { GTK_HAS_GRAB, "GTK_HAS_GRAB", "has-grab" },
+ { GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" },
+ { GTK_BASIC, "GTK_BASIC", "basic" },
+};
+static GtkEnumValue _gtk_private_flags_values[] = {
+ { PRIVATE_GTK_USER_STYLE, "PRIVATE_GTK_USER_STYLE", "user-style" },
+ { PRIVATE_GTK_REDRAW_PENDING, "PRIVATE_GTK_REDRAW_PENDING", "redraw-pending" },
+ { PRIVATE_GTK_RESIZE_PENDING, "PRIVATE_GTK_RESIZE_PENDING", "resize-pending" },
+ { PRIVATE_GTK_RESIZE_NEEDED, "PRIVATE_GTK_RESIZE_NEEDED", "resize-needed" },
+ { PRIVATE_GTK_LEAVE_PENDING, "PRIVATE_GTK_LEAVE_PENDING", "leave-pending" },
+ { PRIVATE_GTK_HAS_SHAPE_MASK, "PRIVATE_GTK_HAS_SHAPE_MASK", "has-shape-mask" },
+ { PRIVATE_GTK_IN_REPARENT, "PRIVATE_GTK_IN_REPARENT", "in-reparent" },
+};
+
--- /dev/null
+/* type entries, generated by maketypes.awk */
+
+ { "GdkWindowType", >K_TYPE_GDK_WINDOW_TYPE,
+ GTK_TYPE_ENUM, _gdk_window_type_values },
+ { "GdkWindowClass", >K_TYPE_GDK_WINDOW_CLASS,
+ GTK_TYPE_ENUM, _gdk_window_class_values },
+ { "GdkImageType", >K_TYPE_GDK_IMAGE_TYPE,
+ GTK_TYPE_ENUM, _gdk_image_type_values },
+ { "GdkVisualType", >K_TYPE_GDK_VISUAL_TYPE,
+ GTK_TYPE_ENUM, _gdk_visual_type_values },
+ { "GdkFontType", >K_TYPE_GDK_FONT_TYPE,
+ GTK_TYPE_ENUM, _gdk_font_type_values },
+ { "GdkWindowAttributesType", >K_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE,
+ GTK_TYPE_FLAGS, _gdk_window_attributes_type_values },
+ { "GdkWindowHints", >K_TYPE_GDK_WINDOW_HINTS,
+ GTK_TYPE_FLAGS, _gdk_window_hints_values },
+ { "GdkFunction", >K_TYPE_GDK_FUNCTION,
+ GTK_TYPE_ENUM, _gdk_function_values },
+ { "GdkFill", >K_TYPE_GDK_FILL,
+ GTK_TYPE_ENUM, _gdk_fill_values },
+ { "GdkFillRule", >K_TYPE_GDK_FILL_RULE,
+ GTK_TYPE_ENUM, _gdk_fill_rule_values },
+ { "GdkLineStyle", >K_TYPE_GDK_LINE_STYLE,
+ GTK_TYPE_ENUM, _gdk_line_style_values },
+ { "GdkCapStyle", >K_TYPE_GDK_CAP_STYLE,
+ GTK_TYPE_ENUM, _gdk_cap_style_values },
+ { "GdkJoinStyle", >K_TYPE_GDK_JOIN_STYLE,
+ GTK_TYPE_ENUM, _gdk_join_style_values },
+ { "GdkFilterReturn", >K_TYPE_GDK_FILTER_RETURN,
+ GTK_TYPE_ENUM, _gdk_filter_return_values },
+ { "GdkVisibilityState", >K_TYPE_GDK_VISIBILITY_STATE,
+ GTK_TYPE_ENUM, _gdk_visibility_state_values },
+ { "GdkEventType", >K_TYPE_GDK_EVENT_TYPE,
+ GTK_TYPE_ENUM, _gdk_event_type_values },
+ { "GdkEventMask", >K_TYPE_GDK_EVENT_MASK,
+ GTK_TYPE_FLAGS, _gdk_event_mask_values },
+ { "GdkNotifyType", >K_TYPE_GDK_NOTIFY_TYPE,
+ GTK_TYPE_ENUM, _gdk_notify_type_values },
+ { "GdkCrossingMode", >K_TYPE_GDK_CROSSING_MODE,
+ GTK_TYPE_ENUM, _gdk_crossing_mode_values },
+ { "GdkModifierType", >K_TYPE_GDK_MODIFIER_TYPE,
+ GTK_TYPE_FLAGS, _gdk_modifier_type_values },
+ { "GdkSubwindowMode", >K_TYPE_GDK_SUBWINDOW_MODE,
+ GTK_TYPE_ENUM, _gdk_subwindow_mode_values },
+ { "GdkInputCondition", >K_TYPE_GDK_INPUT_CONDITION,
+ GTK_TYPE_FLAGS, _gdk_input_condition_values },
+ { "GdkStatus", >K_TYPE_GDK_STATUS,
+ GTK_TYPE_ENUM, _gdk_status_values },
+ { "GdkByteOrder", >K_TYPE_GDK_BYTE_ORDER,
+ GTK_TYPE_ENUM, _gdk_byte_order_values },
+ { "GdkGCValuesMask", >K_TYPE_GDK_G_C_VALUES_MASK,
+ GTK_TYPE_FLAGS, _gdk_g_c_values_mask_values },
+ { "GdkSelection", >K_TYPE_GDK_SELECTION,
+ GTK_TYPE_ENUM, _gdk_selection_values },
+ { "GdkPropertyState", >K_TYPE_GDK_PROPERTY_STATE,
+ GTK_TYPE_ENUM, _gdk_property_state_values },
+ { "GdkPropMode", >K_TYPE_GDK_PROP_MODE,
+ GTK_TYPE_ENUM, _gdk_prop_mode_values },
+ { "GdkDndType", >K_TYPE_GDK_DND_TYPE,
+ GTK_TYPE_ENUM, _gdk_dnd_type_values },
+ { "GdkInputSource", >K_TYPE_GDK_INPUT_SOURCE,
+ GTK_TYPE_ENUM, _gdk_input_source_values },
+ { "GdkInputMode", >K_TYPE_GDK_INPUT_MODE,
+ GTK_TYPE_ENUM, _gdk_input_mode_values },
+ { "GdkAxisUse", >K_TYPE_GDK_AXIS_USE,
+ GTK_TYPE_ENUM, _gdk_axis_use_values },
+ { "GdkTarget", >K_TYPE_GDK_TARGET,
+ GTK_TYPE_ENUM, _gdk_target_values },
+ { "GdkSelectionType", >K_TYPE_GDK_SELECTION_TYPE,
+ GTK_TYPE_ENUM, _gdk_selection_type_values },
+ { "GdkExtensionMode", >K_TYPE_GDK_EXTENSION_MODE,
+ GTK_TYPE_ENUM, _gdk_extension_mode_values },
+ { "GdkWMDecoration", >K_TYPE_GDK_W_M_DECORATION,
+ GTK_TYPE_FLAGS, _gdk_w_m_decoration_values },
+ { "GdkWMFunction", >K_TYPE_GDK_W_M_FUNCTION,
+ GTK_TYPE_FLAGS, _gdk_w_m_function_values },
+ { "GdkColorContextMode", >K_TYPE_GDK_COLOR_CONTEXT_MODE,
+ GTK_TYPE_ENUM, _gdk_color_context_mode_values },
+ { "GdkOverlapType", >K_TYPE_GDK_OVERLAP_TYPE,
+ GTK_TYPE_ENUM, _gdk_overlap_type_values },
+ { "GdkDebugFlag", >K_TYPE_GDK_DEBUG_FLAG,
+ GTK_TYPE_FLAGS, _gdk_debug_flag_values },
+ { "GtkAccelFlags", >K_TYPE_ACCEL_FLAGS,
+ GTK_TYPE_FLAGS, _gtk_accel_flags_values },
+ { "GtkArrowType", >K_TYPE_ARROW_TYPE,
+ GTK_TYPE_ENUM, _gtk_arrow_type_values },
+ { "GtkAttachOptions", >K_TYPE_ATTACH_OPTIONS,
+ GTK_TYPE_FLAGS, _gtk_attach_options_values },
+ { "GtkButtonBoxStyle", >K_TYPE_BUTTON_BOX_STYLE,
+ GTK_TYPE_ENUM, _gtk_button_box_style_values },
+ { "GtkCurveType", >K_TYPE_CURVE_TYPE,
+ GTK_TYPE_ENUM, _gtk_curve_type_values },
+ { "GtkDirectionType", >K_TYPE_DIRECTION_TYPE,
+ GTK_TYPE_ENUM, _gtk_direction_type_values },
+ { "GtkJustification", >K_TYPE_JUSTIFICATION,
+ GTK_TYPE_ENUM, _gtk_justification_values },
+ { "GtkMatchType", >K_TYPE_MATCH_TYPE,
+ GTK_TYPE_ENUM, _gtk_match_type_values },
+ { "GtkMenuFactoryType", >K_TYPE_MENU_FACTORY_TYPE,
+ GTK_TYPE_ENUM, _gtk_menu_factory_type_values },
+ { "GtkMetricType", >K_TYPE_METRIC_TYPE,
+ GTK_TYPE_ENUM, _gtk_metric_type_values },
+ { "GtkOrientation", >K_TYPE_ORIENTATION,
+ GTK_TYPE_ENUM, _gtk_orientation_values },
+ { "GtkPackType", >K_TYPE_PACK_TYPE,
+ GTK_TYPE_ENUM, _gtk_pack_type_values },
+ { "GtkPathPriorityType", >K_TYPE_PATH_PRIORITY_TYPE,
+ GTK_TYPE_ENUM, _gtk_path_priority_type_values },
+ { "GtkPathType", >K_TYPE_PATH_TYPE,
+ GTK_TYPE_ENUM, _gtk_path_type_values },
+ { "GtkPolicyType", >K_TYPE_POLICY_TYPE,
+ GTK_TYPE_ENUM, _gtk_policy_type_values },
+ { "GtkPositionType", >K_TYPE_POSITION_TYPE,
+ GTK_TYPE_ENUM, _gtk_position_type_values },
+ { "GtkPreviewType", >K_TYPE_PREVIEW_TYPE,
+ GTK_TYPE_ENUM, _gtk_preview_type_values },
+ { "GtkReliefStyle", >K_TYPE_RELIEF_STYLE,
+ GTK_TYPE_ENUM, _gtk_relief_style_values },
+ { "GtkScrollType", >K_TYPE_SCROLL_TYPE,
+ GTK_TYPE_ENUM, _gtk_scroll_type_values },
+ { "GtkSelectionMode", >K_TYPE_SELECTION_MODE,
+ GTK_TYPE_ENUM, _gtk_selection_mode_values },
+ { "GtkShadowType", >K_TYPE_SHADOW_TYPE,
+ GTK_TYPE_ENUM, _gtk_shadow_type_values },
+ { "GtkSignalRunType", >K_TYPE_SIGNAL_RUN_TYPE,
+ GTK_TYPE_FLAGS, _gtk_signal_run_type_values },
+ { "GtkStateType", >K_TYPE_STATE_TYPE,
+ GTK_TYPE_ENUM, _gtk_state_type_values },
+ { "GtkSubmenuDirection", >K_TYPE_SUBMENU_DIRECTION,
+ GTK_TYPE_ENUM, _gtk_submenu_direction_values },
+ { "GtkSubmenuPlacement", >K_TYPE_SUBMENU_PLACEMENT,
+ GTK_TYPE_ENUM, _gtk_submenu_placement_values },
+ { "GtkToolbarStyle", >K_TYPE_TOOLBAR_STYLE,
+ GTK_TYPE_ENUM, _gtk_toolbar_style_values },
+ { "GtkTroughType", >K_TYPE_TROUGH_TYPE,
+ GTK_TYPE_ENUM, _gtk_trough_type_values },
+ { "GtkUpdateType", >K_TYPE_UPDATE_TYPE,
+ GTK_TYPE_ENUM, _gtk_update_type_values },
+ { "GtkVisibility", >K_TYPE_VISIBILITY,
+ GTK_TYPE_ENUM, _gtk_visibility_values },
+ { "GtkWindowPosition", >K_TYPE_WINDOW_POSITION,
+ GTK_TYPE_ENUM, _gtk_window_position_values },
+ { "GtkWindowType", >K_TYPE_WINDOW_TYPE,
+ GTK_TYPE_ENUM, _gtk_window_type_values },
+ { "GtkFundamentalType", >K_TYPE_FUNDAMENTAL_TYPE,
+ GTK_TYPE_ENUM, _gtk_fundamental_type_values },
+ { "GtkDebugFlag", >K_TYPE_DEBUG_FLAG,
+ GTK_TYPE_FLAGS, _gtk_debug_flag_values },
+ { "GtkObjectFlags", >K_TYPE_OBJECT_FLAGS,
+ GTK_TYPE_FLAGS, _gtk_object_flags_values },
+ { "GtkArgFlags", >K_TYPE_ARG_FLAGS,
+ GTK_TYPE_FLAGS, _gtk_arg_flags_values },
+ { "GtkWidgetFlags", >K_TYPE_WIDGET_FLAGS,
+ GTK_TYPE_FLAGS, _gtk_widget_flags_values },
+ { "GtkPrivateFlags", >K_TYPE_PRIVATE_FLAGS,
+ GTK_TYPE_FLAGS, _gtk_private_flags_values },
+ { "GtkAccelGroup", >K_TYPE_ACCEL_GROUP,
+ GTK_TYPE_BOXED, NULL },
+ { "GtkSelectionData", >K_TYPE_SELECTION_DATA,
+ GTK_TYPE_BOXED, NULL },
+ { "GtkStyle", >K_TYPE_STYLE,
+ GTK_TYPE_BOXED, NULL },
+ { "GdkColormap", >K_TYPE_GDK_COLORMAP,
+ GTK_TYPE_BOXED, NULL },
+ { "GdkVisual", >K_TYPE_GDK_VISUAL,
+ GTK_TYPE_BOXED, NULL },
+ { "GdkFont", >K_TYPE_GDK_FONT,
+ GTK_TYPE_BOXED, NULL },
+ { "GdkWindow", >K_TYPE_GDK_WINDOW,
+ GTK_TYPE_BOXED, NULL },
+ { "GdkEvent", >K_TYPE_GDK_EVENT,
+ GTK_TYPE_BOXED, NULL },
+ { "GdkColor", >K_TYPE_GDK_COLOR,
+ GTK_TYPE_BOXED, NULL },
--- /dev/null
+/* type variables, generated by maketypes.awk */
+
+GtkType GTK_TYPE_GDK_WINDOW_TYPE = 0;
+GtkType GTK_TYPE_GDK_WINDOW_CLASS = 0;
+GtkType GTK_TYPE_GDK_IMAGE_TYPE = 0;
+GtkType GTK_TYPE_GDK_VISUAL_TYPE = 0;
+GtkType GTK_TYPE_GDK_FONT_TYPE = 0;
+GtkType GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE = 0;
+GtkType GTK_TYPE_GDK_WINDOW_HINTS = 0;
+GtkType GTK_TYPE_GDK_FUNCTION = 0;
+GtkType GTK_TYPE_GDK_FILL = 0;
+GtkType GTK_TYPE_GDK_FILL_RULE = 0;
+GtkType GTK_TYPE_GDK_LINE_STYLE = 0;
+GtkType GTK_TYPE_GDK_CAP_STYLE = 0;
+GtkType GTK_TYPE_GDK_JOIN_STYLE = 0;
+GtkType GTK_TYPE_GDK_FILTER_RETURN = 0;
+GtkType GTK_TYPE_GDK_VISIBILITY_STATE = 0;
+GtkType GTK_TYPE_GDK_EVENT_TYPE = 0;
+GtkType GTK_TYPE_GDK_EVENT_MASK = 0;
+GtkType GTK_TYPE_GDK_NOTIFY_TYPE = 0;
+GtkType GTK_TYPE_GDK_CROSSING_MODE = 0;
+GtkType GTK_TYPE_GDK_MODIFIER_TYPE = 0;
+GtkType GTK_TYPE_GDK_SUBWINDOW_MODE = 0;
+GtkType GTK_TYPE_GDK_INPUT_CONDITION = 0;
+GtkType GTK_TYPE_GDK_STATUS = 0;
+GtkType GTK_TYPE_GDK_BYTE_ORDER = 0;
+GtkType GTK_TYPE_GDK_G_C_VALUES_MASK = 0;
+GtkType GTK_TYPE_GDK_SELECTION = 0;
+GtkType GTK_TYPE_GDK_PROPERTY_STATE = 0;
+GtkType GTK_TYPE_GDK_PROP_MODE = 0;
+GtkType GTK_TYPE_GDK_DND_TYPE = 0;
+GtkType GTK_TYPE_GDK_INPUT_SOURCE = 0;
+GtkType GTK_TYPE_GDK_INPUT_MODE = 0;
+GtkType GTK_TYPE_GDK_AXIS_USE = 0;
+GtkType GTK_TYPE_GDK_TARGET = 0;
+GtkType GTK_TYPE_GDK_SELECTION_TYPE = 0;
+GtkType GTK_TYPE_GDK_EXTENSION_MODE = 0;
+GtkType GTK_TYPE_GDK_W_M_DECORATION = 0;
+GtkType GTK_TYPE_GDK_W_M_FUNCTION = 0;
+GtkType GTK_TYPE_GDK_COLOR_CONTEXT_MODE = 0;
+GtkType GTK_TYPE_GDK_OVERLAP_TYPE = 0;
+GtkType GTK_TYPE_GDK_DEBUG_FLAG = 0;
+GtkType GTK_TYPE_ACCEL_FLAGS = 0;
+GtkType GTK_TYPE_ARROW_TYPE = 0;
+GtkType GTK_TYPE_ATTACH_OPTIONS = 0;
+GtkType GTK_TYPE_BUTTON_BOX_STYLE = 0;
+GtkType GTK_TYPE_CURVE_TYPE = 0;
+GtkType GTK_TYPE_DIRECTION_TYPE = 0;
+GtkType GTK_TYPE_JUSTIFICATION = 0;
+GtkType GTK_TYPE_MATCH_TYPE = 0;
+GtkType GTK_TYPE_MENU_FACTORY_TYPE = 0;
+GtkType GTK_TYPE_METRIC_TYPE = 0;
+GtkType GTK_TYPE_ORIENTATION = 0;
+GtkType GTK_TYPE_PACK_TYPE = 0;
+GtkType GTK_TYPE_PATH_PRIORITY_TYPE = 0;
+GtkType GTK_TYPE_PATH_TYPE = 0;
+GtkType GTK_TYPE_POLICY_TYPE = 0;
+GtkType GTK_TYPE_POSITION_TYPE = 0;
+GtkType GTK_TYPE_PREVIEW_TYPE = 0;
+GtkType GTK_TYPE_RELIEF_STYLE = 0;
+GtkType GTK_TYPE_SCROLL_TYPE = 0;
+GtkType GTK_TYPE_SELECTION_MODE = 0;
+GtkType GTK_TYPE_SHADOW_TYPE = 0;
+GtkType GTK_TYPE_SIGNAL_RUN_TYPE = 0;
+GtkType GTK_TYPE_STATE_TYPE = 0;
+GtkType GTK_TYPE_SUBMENU_DIRECTION = 0;
+GtkType GTK_TYPE_SUBMENU_PLACEMENT = 0;
+GtkType GTK_TYPE_TOOLBAR_STYLE = 0;
+GtkType GTK_TYPE_TROUGH_TYPE = 0;
+GtkType GTK_TYPE_UPDATE_TYPE = 0;
+GtkType GTK_TYPE_VISIBILITY = 0;
+GtkType GTK_TYPE_WINDOW_POSITION = 0;
+GtkType GTK_TYPE_WINDOW_TYPE = 0;
+GtkType GTK_TYPE_FUNDAMENTAL_TYPE = 0;
+GtkType GTK_TYPE_DEBUG_FLAG = 0;
+GtkType GTK_TYPE_OBJECT_FLAGS = 0;
+GtkType GTK_TYPE_ARG_FLAGS = 0;
+GtkType GTK_TYPE_WIDGET_FLAGS = 0;
+GtkType GTK_TYPE_PRIVATE_FLAGS = 0;
+GtkType GTK_TYPE_ACCEL_GROUP = 0;
+GtkType GTK_TYPE_SELECTION_DATA = 0;
+GtkType GTK_TYPE_STYLE = 0;
+GtkType GTK_TYPE_GDK_COLORMAP = 0;
+GtkType GTK_TYPE_GDK_VISUAL = 0;
+GtkType GTK_TYPE_GDK_FONT = 0;
+GtkType GTK_TYPE_GDK_WINDOW = 0;
+GtkType GTK_TYPE_GDK_EVENT = 0;
+GtkType GTK_TYPE_GDK_COLOR = 0;
G_ALLOC_AND_FREE);
}
-GtkType
-gtk_type_unique (GtkType parent_type,
+static GtkType
+gtk_type_create (GtkType parent_type,
+ gchar *type_name,
GtkTypeInfo *type_info)
{
GtkTypeNode *new_node;
GtkTypeNode *parent;
guint i;
- g_return_val_if_fail (type_info != NULL, 0);
-
- if (n_type_nodes == 0)
- gtk_type_init ();
-
- if (g_hash_table_lookup (type_name_2_type_ht, type_info->type_name))
+ if (g_hash_table_lookup (type_name_2_type_ht, type_name))
{
- g_warning ("gtk_type_unique(): type `%s' already exists.", type_info->type_name);
+ g_warning ("gtk_type_create(): type `%s' already exists.", type_name);
return 0;
}
+
if (parent_type)
{
GtkTypeNode *tmp_node;
-
+
LOOKUP_TYPE_NODE (tmp_node, parent_type);
if (!tmp_node)
{
- g_warning ("gtk_type_unique(): unknown parent type `%u'.", parent_type);
+ g_warning ("gtk_type_create(): unknown parent type `%u'.", parent_type);
return 0;
}
}
- /* relookup pointer afterwards.
+ /* relookup pointers afterwards.
*/
new_node = gtk_type_node_next_and_invalidate ();
}
new_node->type_info = *type_info;
- new_node->type_info.type_name = g_strdup (type_info->type_name);
+ new_node->type_info.type_name = type_name;
new_node->n_supers = parent ? parent->n_supers + 1 : 0;
new_node->chunk_alloc_locked = FALSE;
new_node->supers = g_new0 (GtkType, new_node->n_supers + 1);
return new_node->type;
}
+GtkType
+gtk_type_unique (GtkType parent_type,
+ GtkTypeInfo *type_info)
+{
+ GtkType new_type;
+ gchar *type_name;
+
+ g_return_val_if_fail (type_info != NULL, 0);
+ g_return_val_if_fail (type_info->type_name != NULL, 0);
+
+ if (n_type_nodes == 0)
+ gtk_type_init ();
+
+ type_name = g_strdup (type_info->type_name);
+
+ /* relookup pointers afterwards.
+ */
+ new_type = gtk_type_create (parent_type, type_name, type_info);
+
+ if (!new_type)
+ g_free (type_name);
+
+ return new_type;
+}
+
gchar*
gtk_type_name (GtkType type)
{
return (strcmp (a, b) == 0);
}
-static GtkType
-gtk_type_register_builtin (char *name,
+static inline GtkType
+gtk_type_register_builtin (gchar *name,
GtkType parent)
{
GtkTypeInfo info;
info.arg_set_func = NULL;
info.arg_get_func = NULL;
- return gtk_type_unique (parent, &info);
+ return gtk_type_create (parent, name, &info);
}
extern void gtk_object_init_type (void);
-GtkType gtk_type_builtins[GTK_TYPE_NUM_BUILTINS];
-
-#include "makeenums.h" /* include for various places with enum definitions */
-#include "gtktypebuiltins1.c"
+#include "makeenums.h" /* include for various places
+ * with enum definitions
+ */
+#include "gtktypebuiltins_vars.c" /* type variable declarations
+ */
+#include "gtktypebuiltins_evals.c" /* enum value definition arrays
+ */
static void
gtk_type_init_builtin_types (void)
{ GTK_TYPE_C_CALLBACK, "c_callback" }
};
struct {
- gchar *name;
+ gchar *type_name;
+ GtkType *type_id;
GtkType parent;
GtkEnumValue *values;
- } builtin_info[] = {
-#include "gtktypebuiltins2.c"
+ } builtin_info[GTK_TYPE_NUM_BUILTINS + 1] = {
+#include "gtktypebuiltins_ids.c" /* type entries */
{ NULL }
};
guint i;
for (i = 0; i < sizeof (fundamental_info) / sizeof (fundamental_info[0]); i++)
{
- GtkType id;
+ GtkType type_id;
- id = gtk_type_register_builtin (fundamental_info[i].name,
+ type_id = gtk_type_register_builtin (fundamental_info[i].name,
GTK_TYPE_INVALID);
- g_assert (id == fundamental_info[i].type_id);
+
+ g_assert (type_id == fundamental_info[i].type_id);
}
gtk_object_init_type ();
- for (i = 0; builtin_info[i].name; i++)
+ for (i = 0; i < GTK_TYPE_NUM_BUILTINS; i++)
{
- gtk_type_builtins[i] =
- gtk_type_register_builtin (builtin_info[i].name,
+ GtkType type_id;
+
+ g_assert (builtin_info[i].type_name != NULL);
+
+ type_id =
+ gtk_type_register_builtin (builtin_info[i].type_name,
builtin_info[i].parent);
- if (gtk_type_is_a (gtk_type_builtins[i], GTK_TYPE_ENUM) ||
- gtk_type_is_a (gtk_type_builtins[i], GTK_TYPE_FLAGS))
- gtk_enum_set_values (gtk_type_builtins[i], builtin_info[i].values);
+
+ g_assert (type_id != GTK_TYPE_INVALID);
+
+ (*builtin_info[i].type_id) = type_id;
+
+ if (builtin_info[i].values)
+ {
+ g_assert (gtk_type_is_a (type_id, GTK_TYPE_ENUM) ||
+ gtk_type_is_a (type_id, GTK_TYPE_FLAGS));
+
+ gtk_enum_set_values (type_id, builtin_info[i].values);
+ }
}
}
/* Builtin Types
*/
-extern GtkType gtk_type_builtins[];
#include <gtk/gtktypebuiltins.h>
/* Macros
GdkRectangle *area);
static void gtk_widget_real_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
+static gint gtk_widget_real_key_press_event (GtkWidget *widget,
+ GdkEventKey *event);
static void gtk_widget_style_set (GtkWidget *widget,
GtkStyle *previous_style);
GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
gtk_widget_marshal_signal_5,
GTK_TYPE_NONE, 1,
- GTK_TYPE_UINT);
+ GTK_TYPE_STATE_TYPE);
widget_signals[PARENT_SET] =
gtk_signal_new ("parent_set",
GTK_RUN_FIRST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
gtk_widget_marshal_signal_7,
GTK_TYPE_NONE, 1,
- GTK_TYPE_BOXED);
+ GTK_TYPE_STYLE);
widget_signals[ADD_ACCELERATOR] =
gtk_accel_group_create_add (object_class->type, GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, add_accelerator));
object_class->type,
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
gtk_widget_marshal_signal_1,
- GTK_TYPE_BOOL, 1,
- GTK_TYPE_GDK_EVENT);
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_SELECTION_DATA);
widget_signals[PROXIMITY_IN_EVENT] =
gtk_signal_new ("proximity_in_event",
GTK_RUN_LAST,
klass->delete_event = NULL;
klass->destroy_event = NULL;
klass->expose_event = NULL;
- klass->key_press_event = NULL;
+ klass->key_press_event = gtk_widget_real_key_press_event;
klass->key_release_event = NULL;
klass->enter_notify_event = NULL;
klass->leave_notify_event = NULL;
return 0;
}
+static gint
+gtk_widget_real_key_press_event (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ gboolean handled = FALSE;
+
+ g_return_val_if_fail (widget != NULL, handled);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), handled);
+ g_return_val_if_fail (event != NULL, handled);
+
+ if (!handled)
+ handled = gtk_bindings_activate (GTK_OBJECT (widget),
+ event->keyval, event->state);
+
+ return handled;
+}
+
/*****************************************
* gtk_widget_event:
*
void (* size_allocate) (GtkWidget *widget,
GtkAllocation *allocation);
void (* state_changed) (GtkWidget *widget,
- guint previous_state);
+ GtkStateType previous_state);
void (* parent_set) (GtkWidget *widget,
GtkWidget *previous_parent);
void (* style_set) (GtkWidget *widget,
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods,
+ GdkModifierType accel_mods,
GtkAccelFlags accel_flags);
void (* remove_accelerator) (GtkWidget *widget,
GtkAccelGroup *accel_group,
guint accel_key,
- guint accel_mods);
+ GdkModifierType accel_mods);
/* events */
gint (* event) (GtkWidget *widget,
GdkEventOther *event);
/* selection */
- void (* selection_received) (GtkWidget *widget,
- GtkSelectionData *selection_data);
+ void (* selection_received) (GtkWidget *widget,
+ GtkSelectionData *selection_data);
};
struct _GtkWidgetAuxInfo
gtk_object_add_arg_type ("GtkWindow::auto_shrink", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_AUTO_SHRINK);
gtk_object_add_arg_type ("GtkWindow::allow_shrink", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ALLOW_SHRINK);
gtk_object_add_arg_type ("GtkWindow::allow_grow", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ALLOW_GROW);
- gtk_object_add_arg_type ("GtkWindow::window_position", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_WIN_POS);
+ gtk_object_add_arg_type ("GtkWindow::window_position", GTK_TYPE_WINDOW_POSITION, GTK_ARG_READWRITE, ARG_WIN_POS);
window_signals[MOVE_RESIZE] =
gtk_signal_new ("move_resize",
if (window->focus_widget)
{
handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
-
- if (!handled)
- handled = gtk_bindings_activate (GTK_OBJECT (window->focus_widget),
- event->keyval, event->state);
}
if (!handled)
}
}
+ if (!handled && GTK_WIDGET_CLASS (parent_class)->key_press_event)
+ handled = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
+
return handled;
}
if (window->focus_widget)
{
handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
-
- if (!handled)
- handled = gtk_bindings_activate (GTK_OBJECT (window->focus_widget),
- event->keyval, event->state | GDK_AFTER_MASK);
}
-
+
+ if (!handled && GTK_WIDGET_CLASS (parent_class)->key_release_event)
+ handled = GTK_WIDGET_CLASS (parent_class)->key_release_event (widget, event);
+
return handled;
}
VI = 0;
gen_arrays = 0;
gen_defs = 0;
+ comment_file = "";
for (i = 1; i < ARGC; i++)
{
{
if (gen_arrays)
{
- printf ("static GtkEnumValue enum_values_%s[] = {\n", type_name);
+ printf ("static GtkEnumValue %s_values[] = {\n", type_ident);
for (i = 0; i < VI; i++)
{
printf (" { %s, \"%s\", \"%s\" },\n",
{
if (gen_defs)
{
+ if (comment_file != "")
+ {
+ printf ("\n; enumerations from \"%s\"\n", comment_file);
+ comment_file = "";
+ }
+
printf ("\n(define-%s %s",
type_flags ? "flags" : "enum",
type_name);
}
}
+function basename (basename_1)
+{
+ sub ("\"", "", basename_1);
+ while (match (basename_1, "/"))
+ sub (".*/", "", basename_1);
+ sub ("\"", "", basename_1);
+ return basename_1;
+}
+
# parse keywords
/G_ENUM_E/ {
VI += 1;
}
+# feature per file comments
+/# / {
+ comment_file = basename($3);
+}
+
END {
printf("\n");
}
+#include <gdk/gdkprivate.h>
+#include <gdk/gdk.h>
#include <gtk/gtk.h>
#include <gtk/gtkprivate.h>
#include <gtk/gtkdebug.h>
-#include <gdk/gdkprivate.h>
--- /dev/null
+
+BEGIN {
+ type_name = ""; # GtkEnumType
+ type_macro = ""; # GTK_TYPE_ENUM_TYPE
+ type_ident = ""; # _gtk_enum_type
+ type_counter = 0;
+ gen_macros = 0;
+ gen_entries = 0;
+ gen_vars = 0;
+
+ for (i = 2; i < ARGC; i++)
+ {
+ if (ARGV[i] == "macros")
+ gen_macros = 1;
+ else if (ARGV[i] == "entries")
+ gen_entries = 1;
+ else if (ARGV[i] == "variables")
+ gen_vars = 1;
+ ARGV[i] = "";
+ }
+
+ if (gen_macros)
+ printf ("/* type macros, generated by maketypes.awk */\n\n");
+ else if (gen_entries)
+ printf ("/* type entries, generated by maketypes.awk */\n\n");
+ else if (gen_vars)
+ printf ("/* type variables, generated by maketypes.awk */\n\n");
+ else
+ {
+ printf ("hm? what do you want me to do?\n") > "/dev/stderr";
+ exit 1;
+ }
+}
+
+function set_type (set_type_1)
+{
+ type_counter += 1;
+ type_name = set_type_1;
+ type_macro = "GTK_TYPE";
+ type_ident = "";
+ for (i = 0; i < length (type_name); i++)
+ {
+ ch = substr (type_name, i + 1, 1);
+ Ch = toupper (ch);
+ if (Ch == ch)
+ {
+ type_macro = type_macro "_" Ch;
+ type_ident = type_ident "_" tolower (ch);
+ }
+ else
+ {
+ type_macro = type_macro Ch;
+ type_ident = type_ident ch;
+ }
+ }
+ sub ("^GTK_TYPE_GTK_", "GTK_TYPE_", type_macro);
+}
+
+function generate (generate_1)
+{
+ if (gen_macros)
+ {
+ printf ("extern GtkType %s;\n", type_macro);
+ }
+ if (gen_entries)
+ {
+ printf (" { \"%s\", &%s,\n", type_name, type_macro);
+ if (generate_1 == "BOXED")
+ printf (" GTK_TYPE_%s, NULL },\n", generate_1);
+ else
+ printf (" GTK_TYPE_%s, %s_values },\n", generate_1, type_ident);
+ }
+ if (gen_vars)
+ {
+ printf ("GtkType %s = 0;\n", type_macro);
+ }
+}
+
+# skip scheme comments
+";" {
+ sub (";.*", "");
+}
+
+# parse keywords
+
+/\(define-enum/ {
+ if ($2 == "")
+ printf ("huh? define-enum keyword without arg?\n") > "/dev/stderr";
+ else
+ {
+ set_type($2);
+ generate("ENUM");
+ }
+}
+
+/\(define-flags/ {
+ if ($2 == "")
+ printf ("huh? define-flags keyword without arg?\n") > "/dev/stderr";
+ else
+ {
+ set_type($2);
+ generate("FLAGS");
+ }
+}
+
+/\(define-boxed/ {
+ if ($2 == "")
+ printf ("huh? define-boxed keyword without arg?\n") > "/dev/stderr";
+ else
+ {
+ set_type($2);
+ generate("BOXED");
+ }
+}
+
+END {
+ if (gen_macros)
+ printf("\n#define\tGTK_TYPE_NUM_BUILTINS\t(%u)\n", type_counter);
+}
+++ /dev/null
-#! /bin/sh
-if test $# -lt 1; then
- echo >&2 "usage: $0 file.el"
- exit 1
-fi
-exec emacs --no-init-file --no-site-file --batch --load $*
projects / gtk4.git / commitdiff